Leverage derive_more::Display

Author: tyranron

book/src/types/scalars.md

@@ -345,7 +345,7 @@ For implementing [custom scalars][2] on foreign types there is [`#[graphql_scala
 #    }
 #
 #    impl std::fmt::Display for Date {
-#        fn fmt(&self, _f: &mut std::fmt::Formatter) -> std::fmt::Result {
+#        fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 #            unimplemented!()
 #        }
 #    }

juniper/Cargo.toml

@@ -51,6 +51,7 @@ bson = { version = "2.4", optional = true }
 chrono = { version = "0.4.30", features = ["alloc"], default-features = false, optional = true }
 chrono-tz = { version = "0.10", default-features = false, optional = true }
 compact_str = "0.9"
+derive_more = { version = "2.0", features = ["display"] }
 fnv = "1.0.5"
 futures = { version = "0.3.22", features = ["alloc"], default-features = false }
 graphql-parser = { version = "0.4", optional = true }

juniper/src/integrations/jiff.rs

@@ -52,6 +52,8 @@
 
 use std::{error::Error, fmt, str};
 
+use derive_more::with_trait::Display;
+
 use crate::{InputValue, ScalarValue, Value, graphql_scalar};
 
 /// Representation of a civil date in the Gregorian calendar.
@@ -409,12 +411,13 @@ mod time_zone_or_utc_offset {
 }
 
 /// Error parsing a [`TimeZone`] value.
-#[derive(Clone)]
+#[derive(Clone, Display)]
 pub enum TimeZoneParsingError {
     /// Identifier cannot not be parsed by the [`jiff::tz::TimeZone::get()`] method.
     InvalidTimeZone(jiff::Error),
 
     /// GraphQL scalar [`TimeZone`] requires `tz::TimeZone` with IANA name.
+    #[display("missing IANA name")]
     MissingIanaName(jiff::tz::TimeZone),
 }
 
@@ -427,15 +430,6 @@ impl fmt::Debug for TimeZoneParsingError {
     }
 }
 
-impl fmt::Display for TimeZoneParsingError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::InvalidTimeZone(e) => e.fmt(f),
-            Self::MissingIanaName(..) => write!(f, "missing IANA name"),
-        }
-    }
-}
-
 impl Error for TimeZoneParsingError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         match self {
@@ -463,7 +457,8 @@ impl Error for TimeZoneParsingError {
     parse_token(String),
     specified_by_url = "https://graphql-scalars.dev/docs/scalars/time-zone",
 )]
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Display, Eq, PartialEq)]
+#[display("{}", _0.iana_name().expect("failed to display `TimeZone`: no IANA name"))]
 pub struct TimeZone(jiff::tz::TimeZone);
 
 impl TryFrom<jiff::tz::TimeZone> for TimeZone {
@@ -487,18 +482,6 @@ impl str::FromStr for TimeZone {
     }
 }
 
-impl fmt::Display for TimeZone {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0
-            .iana_name()
-            .unwrap_or_else(|| {
-                // PANIC: We made sure that IANA name is available when constructing `Self`.
-                panic!("failed to display `TimeZone`: no IANA name")
-            })
-            .fmt(f)
-    }
-}
-
 impl From<TimeZone> for jiff::tz::TimeZone {
     fn from(value: TimeZone) -> Self {
         value.0

juniper/src/lib.rs

@@ -14,8 +14,6 @@ mod for_benches_only {
     use bencher as _;
 }
 
-use std::fmt;
-
 // These are required by the code generated via the `juniper_codegen` macros.
 #[doc(hidden)]
 pub use {async_trait::async_trait, futures, serde, static_assertions as sa};
@@ -58,6 +56,9 @@ pub mod tests;
 #[cfg(test)]
 mod executor_tests;
 
+use derive_more::with_trait::Display;
+use itertools::Itertools as _;
+
 // Needs to be public because macros use it.
 pub use crate::util::to_camel_case;
 
@@ -106,36 +107,23 @@ pub use crate::{
 
 /// An error that prevented query execution
 #[expect(missing_docs, reason = "self-explanatory")]
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Display, Eq, PartialEq)]
 pub enum GraphQLError {
     ParseError(Spanning<ParseError>),
+    #[display("{}", _0.iter().format("\n"))]
     ValidationError(Vec<RuleError>),
+    #[display("No operation provided")]
     NoOperationProvided,
+    #[display("Multiple operations provided")]
     MultipleOperationsProvided,
+    #[display("Unknown operation name")]
     UnknownOperationName,
+    #[display("Operation is a subscription")]
     IsSubscription,
+    #[display("Operation is not a subscription")]
     NotSubscription,
 }
 
-impl fmt::Display for GraphQLError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::ParseError(e) => write!(f, "{e}"),
-            Self::ValidationError(errs) => {
-                for e in errs {
-                    writeln!(f, "{e}")?;
-                }
-                Ok(())
-            }
-            Self::NoOperationProvided => write!(f, "No operation provided"),
-            Self::MultipleOperationsProvided => write!(f, "Multiple operations provided"),
-            Self::UnknownOperationName => write!(f, "Unknown operation name"),
-            Self::IsSubscription => write!(f, "Operation is a subscription"),
-            Self::NotSubscription => write!(f, "Operation is not a subscription"),
-        }
-    }
-}
-
 impl std::error::Error for GraphQLError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {

juniper/src/parser/lexer.rs

@@ -1,4 +1,6 @@
-use std::{char, fmt, iter::Peekable, str::CharIndices};
+use std::{char, iter::Peekable, str::CharIndices};
+
+use derive_more::with_trait::Display;
 
 use crate::parser::{SourcePosition, Spanning};
 
@@ -16,76 +18,98 @@ pub struct Lexer<'a> {
 ///
 /// This is only used for tagging how the lexer has interpreted a value literal
 #[expect(missing_docs, reason = "self-explanatory")]
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Display, Eq, PartialEq)]
 pub enum ScalarToken<'a> {
+    #[display("\"{}\"", _0.replace('\\', "\\\\").replace('"', "\\\""))]
     String(&'a str),
     Float(&'a str),
     Int(&'a str),
 }
 
 /// A single token in the input source
 #[expect(missing_docs, reason = "self-explanatory")]
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Display, Eq, PartialEq)]
 pub enum Token<'a> {
     Name(&'a str),
     Scalar(ScalarToken<'a>),
+    #[display("!")]
     ExclamationMark,
+    #[display("$")]
     Dollar,
+    #[display("(")]
     ParenOpen,
+    #[display(")")]
     ParenClose,
+    #[display("[")]
     BracketOpen,
+    #[display("]")]
     BracketClose,
+    #[display("{{")]
     CurlyOpen,
+    #[display("}}")]
     CurlyClose,
+    #[display("...")]
     Ellipsis,
+    #[display(":")]
     Colon,
+    #[display("=")]
     Equals,
+    #[display("@")]
     At,
+    #[display("|")]
     Pipe,
+    #[display("End of file")]
     EndOfFile,
 }
 
 /// Error when tokenizing the input source
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, Display, Eq, PartialEq)]
 pub enum LexerError {
     /// An unknown character was found
     ///
     /// Unknown characters are characters that do not occur anywhere in the
     /// GraphQL language, such as `?` or `%`.
+    #[display("Unknown character \"{_0}\"")]
     UnknownCharacter(char),
 
     /// An unexpected character was found
     ///
     /// Unexpected characters are characters that _do_ exist in the GraphQL
     /// language, but is not expected at the current position in the document.
+    #[display("Unexpected character \"{_0}\"")]
     UnexpectedCharacter(char),
 
     /// An unterminated string literal was found
     ///
     /// Apart from forgetting the ending `"`, terminating a string within a
     /// Unicode escape sequence or having a line break in the string also
     /// causes this error.
+    #[display("Unterminated string literal")]
     UnterminatedString,
 
     /// An unknown character in a string literal was found
     ///
     /// This occurs when an invalid source character is found in a string
     /// literal, such as ASCII control characters.
+    #[display("Unknown character \"{_0}\" in string literal")]
     UnknownCharacterInString(char),
 
     /// An unknown escape sequence in a string literal was found
     ///
     /// Only a limited set of escape sequences are supported, this is emitted
     /// when e.g. `"\l"` is parsed.
+    #[display("Unknown escape sequence \"{_0}\" in string")]
     UnknownEscapeSequence(String),
 
     /// The input source was unexpectedly terminated
     ///
     /// Emitted when the current token requires a succeeding character, but
     /// the source has reached EOF. Emitted when scanning e.g. `"1."`.
+    #[display("Unexpected end of input")]
     UnexpectedEndOfFile,
 
     /// An invalid number literal was found
+    #[display("Invalid number literal")]
     InvalidNumber,
 }
 
@@ -477,34 +501,6 @@ impl<'a> Iterator for Lexer<'a> {
     }
 }
 
-impl fmt::Display for Token<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Token::Name(name) => write!(f, "{name}"),
-            Token::Scalar(ScalarToken::Int(s)) | Token::Scalar(ScalarToken::Float(s)) => {
-                write!(f, "{s}")
-            }
-            Token::Scalar(ScalarToken::String(s)) => {
-                write!(f, "\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\""))
-            }
-            Token::ExclamationMark => write!(f, "!"),
-            Token::Dollar => write!(f, "$"),
-            Token::ParenOpen => write!(f, "("),
-            Token::ParenClose => write!(f, ")"),
-            Token::BracketOpen => write!(f, "["),
-            Token::BracketClose => write!(f, "]"),
-            Token::CurlyOpen => write!(f, "{{"),
-            Token::CurlyClose => write!(f, "}}"),
-            Token::Ellipsis => write!(f, "..."),
-            Token::Colon => write!(f, ":"),
-            Token::Equals => write!(f, "="),
-            Token::At => write!(f, "@"),
-            Token::Pipe => write!(f, "|"),
-            Token::EndOfFile => write!(f, "End of file"),
-        }
-    }
-}
-
 fn is_source_char(c: char) -> bool {
     c == '\t' || c == '\n' || c == '\r' || c >= ' '
 }
@@ -521,22 +517,4 @@ fn is_number_start(c: char) -> bool {
     c == '-' || c.is_ascii_digit()
 }
 
-impl fmt::Display for LexerError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            LexerError::UnknownCharacter(c) => write!(f, "Unknown character \"{c}\""),
-            LexerError::UnterminatedString => write!(f, "Unterminated string literal"),
-            LexerError::UnknownCharacterInString(c) => {
-                write!(f, "Unknown character \"{c}\" in string literal")
-            }
-            LexerError::UnknownEscapeSequence(ref s) => {
-                write!(f, "Unknown escape sequence \"{s}\" in string")
-            }
-            LexerError::UnexpectedCharacter(c) => write!(f, "Unexpected character \"{c}\""),
-            LexerError::UnexpectedEndOfFile => write!(f, "Unexpected end of input"),
-            LexerError::InvalidNumber => write!(f, "Invalid number literal"),
-        }
-    }
-}
-
 impl std::error::Error for LexerError {}

juniper/src/parser/parser.rs

@@ -1,18 +1,21 @@
 use std::{error::Error, fmt};
 
 use compact_str::{CompactString, format_compact};
+use derive_more::with_trait::Display;
 
 use crate::parser::{Lexer, LexerError, Spanning, Token};
 
 /// Error while parsing a GraphQL query
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Display, Eq, PartialEq)]
 pub enum ParseError {
     /// An unexpected token occurred in the source
     // TODO: Previously was `Token<'a>`.
     //       Revisit on `graphql-parser` integration.
+    #[display("Unexpected \"{_0}\"")]
     UnexpectedToken(CompactString),
 
     /// The input source abruptly ended
+    #[display("Unexpected end of input")]
     UnexpectedEndOfFile,
 
     /// An error during tokenization occurred
@@ -22,17 +25,6 @@ pub enum ParseError {
     ExpectedScalarError(&'static str),
 }
 
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::UnexpectedToken(token) => write!(f, "Unexpected \"{token}\""),
-            Self::UnexpectedEndOfFile => write!(f, "Unexpected end of input"),
-            Self::LexerError(e) => e.fmt(f),
-            Self::ExpectedScalarError(e) => e.fmt(f),
-        }
-    }
-}
-
 impl Error for ParseError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         match self {

juniper/src/parser/utils.rs

@@ -1,7 +1,10 @@
 use std::fmt;
 
+use derive_more::with_trait::Display;
+
 /// A reference to a line and column in an input source file
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
+#[derive(Clone, Copy, Debug, Display, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[display("{line}:{col}")]
 pub struct SourcePosition {
     index: usize,
     line: usize,
@@ -136,8 +139,8 @@ impl<T> Spanning<T, Span> {
     }
 }
 
-impl<T: fmt::Display> fmt::Display for Spanning<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl<T: Display> Display for Spanning<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}. At {}", self.item, self.span.start)
     }
 }
@@ -196,9 +199,3 @@ impl SourcePosition {
         self.col
     }
 }
-
-impl fmt::Display for SourcePosition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}:{}", self.line, self.col)
-    }
-}