use inline format args (clippy::uninlined_format_args)

daniel.eades · daniel.eades · commit e7321458e669 · 2025-02-11T16:02:20.000Z
diff --git a/examples/github/examples/github.rs b/examples/github/examples/github.rs
@@ -52,7 +52,7 @@ fn main() -> Result<(), anyhow::Error> {
         .default_headers(
             std::iter::once((
                 reqwest::header::AUTHORIZATION,
-                reqwest::header::HeaderValue::from_str(&format!("Bearer {}", github_api_token))
+                reqwest::header::HeaderValue::from_str(&format!("Bearer {github_api_token}"))
                     .unwrap(),
             ))
             .collect(),
diff --git a/examples/web/src/lib.rs b/examples/web/src/lib.rs
@@ -36,7 +36,7 @@ async fn load_more() -> Result<JsValue, JsValue> {
     let response = post_graphql::<PuppySmiles, _>(&client, url, variables)
         .await
         .map_err(|err| {
-            log(&format!("Could not fetch puppies. error: {:?}", err));
+            log(&format!("Could not fetch puppies. error: {err:?}"));
             JsValue::NULL
         })?;
     render_response(response);
@@ -77,7 +77,7 @@ fn add_load_more_button() {
 fn render_response(response: graphql_client::Response<puppy_smiles::ResponseData>) {
     use std::fmt::Write;
 
-    log(&format!("response body\n\n{:?}", response));
+    log(&format!("response body\n\n{response:?}"));
 
     let parent = document().body().expect_throw("no body");
 
@@ -116,8 +116,7 @@ fn render_response(response: graphql_client::Response<puppy_smiles::ResponseData
         .expect_throw("write to string");
     }
     response.set_inner_html(&format!(
-        "<h2>response:</h2><div class=\"container\"><div class=\"row\">{}</div></div>",
-        inner_html
+        "<h2>response:</h2><div class=\"container\"><div class=\"row\">{inner_html}</div></div>"
     ));
     parent
         .append_child(&response)
diff --git a/graphql_client/src/lib.rs b/graphql_client/src/lib.rs
@@ -122,8 +122,8 @@ pub enum PathFragment {
 impl Display for PathFragment {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            PathFragment::Key(ref key) => write!(f, "{}", key),
-            PathFragment::Index(ref idx) => write!(f, "{}", idx),
+            PathFragment::Key(ref key) => write!(f, "{key}"),
+            PathFragment::Index(ref idx) => write!(f, "{idx}"),
         }
     }
 }
@@ -217,7 +217,7 @@ impl Display for Error {
                 fragments
                     .iter()
                     .fold(String::new(), |mut acc, item| {
-                        let _ = write!(acc, "{}/", item);
+                        let _ = write!(acc, "{item}/");
                         acc
                     })
                     .trim_end_matches('/')
diff --git a/graphql_client/tests/extern_enums.rs b/graphql_client/tests/extern_enums.rs
@@ -50,7 +50,7 @@ pub struct MultipleExternEnumsQuery;
 fn single_extern_enum() {
     const RESPONSE: &str = include_str!("extern_enums/single_extern_enum_response.json");
 
-    println!("{:?}", RESPONSE);
+    println!("{RESPONSE:?}");
     let response_data: single_extern_enum_query::ResponseData =
         serde_json::from_str(RESPONSE).unwrap();
 
@@ -67,11 +67,11 @@ fn single_extern_enum() {
 fn multiple_extern_enums() {
     const RESPONSE: &str = include_str!("extern_enums/multiple_extern_enums_response.json");
 
-    println!("{:?}", RESPONSE);
+    println!("{RESPONSE:?}");
     let response_data: multiple_extern_enums_query::ResponseData =
         serde_json::from_str(RESPONSE).unwrap();
 
-    println!("{:?}", response_data);
+    println!("{response_data:?}");
 
     let expected = multiple_extern_enums_query::ResponseData {
         distance: 100,
diff --git a/graphql_client/tests/interfaces.rs b/graphql_client/tests/interfaces.rs
@@ -14,10 +14,10 @@ pub struct InterfaceQuery;
 fn interface_deserialization() {
     use interface_query::*;
 
-    println!("{:?}", RESPONSE);
+    println!("{RESPONSE:?}");
     let response_data: interface_query::ResponseData = serde_json::from_str(RESPONSE).unwrap();
 
-    println!("{:?}", response_data);
+    println!("{response_data:?}");
 
     let expected = ResponseData {
         everything: Some(vec![
diff --git a/graphql_client/tests/json_schema.rs b/graphql_client/tests/json_schema.rs
@@ -33,7 +33,7 @@ fn json_schemas_work_with_and_without_data_field() {
         serde_json::from_value(response).unwrap();
 
     assert_eq!(
-        format!("{:?}", schema_1_result),
+        format!("{schema_1_result:?}"),
         format!("{:?}", schema_2_result)
     );
 }
diff --git a/graphql_client/tests/skip_serializing_none.rs b/graphql_client/tests/skip_serializing_none.rs
@@ -27,7 +27,7 @@ fn skip_serializing_none() {
 
     let stringified = serde_json::to_string(&query).expect("SkipSerializingNoneMutation is valid");
 
-    println!("{}", stringified);
+    println!("{stringified}");
 
     assert!(stringified.contains(r#""param":{"data":{"name":"test"}}"#));
     assert!(stringified.contains(r#""nonOptionalInt":1337"#));
@@ -48,7 +48,7 @@ fn skip_serializing_none() {
         }),
     });
     let stringified = serde_json::to_string(&query).expect("SkipSerializingNoneMutation is valid");
-    println!("{}", stringified);
+    println!("{stringified}");
     assert!(stringified.contains(r#""param":{"data":{"name":"test"}}"#));
     assert!(stringified.contains(r#""nonOptionalInt":1337"#));
     assert!(stringified.contains(r#""nonOptionalList":[]"#));
diff --git a/graphql_client_cli/src/generate.rs b/graphql_client_cli/src/generate.rs
@@ -91,9 +91,9 @@ pub(crate) fn generate_code(params: CliCodegenParams) -> CliResult<()> {
     }
 
     let gen = generate_module_token_stream(query_path.clone(), &schema_path, options)
-        .map_err(|err| Error::message(format!("Error generating module code: {}", err)))?;
+        .map_err(|err| Error::message(format!("Error generating module code: {err}")))?;
 
-    let generated_code = format!("{}\n{}", WARNING_SUPPRESSION, gen);
+    let generated_code = format!("{WARNING_SUPPRESSION}\n{gen}");
     let generated_code = if !no_formatting {
         format(&generated_code)?
     } else {
@@ -120,7 +120,7 @@ pub(crate) fn generate_code(params: CliCodegenParams) -> CliResult<()> {
             format!("Creating file at {}", dest_file_path.display()),
         )
     })?;
-    write!(file, "{}", generated_code)?;
+    write!(file, "{generated_code}")?;
 
     Ok(())
 }
@@ -134,7 +134,7 @@ fn format(code: &str) -> CliResult<String> {
         .spawn()
         .map_err(|err| Error::source_with_message(err, "Error spawning rustfmt".to_owned()))?;
     let child_stdin = child.stdin.as_mut().unwrap();
-    write!(child_stdin, "{}", code)?;
+    write!(child_stdin, "{code}")?;
 
     let output = child.wait_with_output()?;
 
diff --git a/graphql_client_cli/src/introspection_schema.rs b/graphql_client_cli/src/introspection_schema.rs
@@ -80,9 +80,9 @@ pub fn introspect_schema(
         let error_message = match res.text() {
             Ok(msg) => match serde_json::from_str::<serde_json::Value>(&msg) {
                 Ok(json) => format!("HTTP {}\n{}", status, serde_json::to_string_pretty(&json)?),
-                Err(_) => format!("HTTP {}: {}", status, msg),
+                Err(_) => format!("HTTP {status}: {msg}"),
             },
-            Err(_) => format!("HTTP {}", status),
+            Err(_) => format!("HTTP {status}"),
         };
         return Err(Error::message(error_message));
     }
@@ -113,8 +113,7 @@ impl FromStr for Header {
         // error: colon required for name/value pair
         if !input.contains(':') {
             return Err(format!(
-                "Invalid header input. A colon is required to separate the name and value. [{}]",
-                input
+                "Invalid header input. A colon is required to separate the name and value. [{input}]"
             ));
         }
 
@@ -126,16 +125,14 @@ impl FromStr for Header {
         // error: field name must be
         if name.is_empty() {
             return Err(format!(
-                "Invalid header input. Field name is required before colon. [{}]",
-                input
+                "Invalid header input. Field name is required before colon. [{input}]"
             ));
         }
 
         // error: no whitespace in field name
         if name.split_whitespace().count() > 1 {
             return Err(format!(
-                "Invalid header input. Whitespace not allowed in field name. [{}]",
-                input
+                "Invalid header input. Whitespace not allowed in field name. [{input}]"
             ));
         }
 
@@ -196,12 +193,7 @@ mod tests {
             let header = Header::from_str(input);
 
             assert!(header.is_ok(), "Expected ok: [{}]", input);
-            assert_eq!(
-                header.unwrap(),
-                **expected,
-                "Expected equality: [{}]",
-                input
-            );
+            assert_eq!(header.unwrap(), **expected, "Expected equality: [{input}]");
         }
     }
 }
diff --git a/graphql_client_codegen/src/codegen.rs b/graphql_client_codegen/src/codegen.rs
@@ -181,7 +181,7 @@ fn generate_scalar_definitions<'a, 'schema: 'a>(
 fn render_derives<'a>(derives: impl Iterator<Item = &'a str>) -> impl quote::ToTokens {
     let idents = derives.map(|s| {
         syn::parse_str::<syn::Path>(s)
-            .map_err(|e| format!("couldn't parse {} as a derive Path: {}", s, e))
+            .map_err(|e| format!("couldn't parse {s} as a derive Path: {e}"))
             .unwrap()
     });
 
diff --git a/graphql_client_codegen/src/lib.rs b/graphql_client_codegen/src/lib.rs
@@ -61,7 +61,7 @@ fn get_set_cached<T: Clone>(
 
 fn query_document(query_string: &str) -> Result<QueryDocument, BoxError> {
     let document = graphql_parser::parse_query(query_string)
-        .map_err(|err| GeneralError(format!("Query parser error: {}", err)))?
+        .map_err(|err| GeneralError(format!("Query parser error: {err}")))?
         .into_static();
     Ok(document)
 }
@@ -83,7 +83,7 @@ fn get_set_schema_from_file(schema_path: &std::path::Path) -> Schema {
         let schema_string = read_file(schema_path).unwrap();
         match schema_extension {
             "graphql" | "graphqls"| "gql" => {
-                let s = graphql_parser::schema::parse_schema::<&str>(&schema_string).map_err(|parser_error| GeneralError(format!("Parser error: {}", parser_error))).unwrap();
+                let s = graphql_parser::schema::parse_schema::<&str>(&schema_string).map_err(|parser_error| GeneralError(format!("Parser error: {parser_error}"))).unwrap();
                 Schema::from(s)
             }
             "json" => {
@@ -179,8 +179,8 @@ impl Display for ReadFileError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             ReadFileError::FileNotFound { path, .. } => {
-                write!(f, "Could not find file with path: {}\n
-                Hint: file paths in the GraphQLQuery attribute are relative to the project root (location of the Cargo.toml). Example: query_path = \"src/my_query.graphql\".", path)
+                write!(f, "Could not find file with path: {path}\n
+                Hint: file paths in the GraphQLQuery attribute are relative to the project root (location of the Cargo.toml). Example: query_path = \"src/my_query.graphql\".")
             }
             ReadFileError::ReadError { path, .. } => {
                 f.write_str("Error reading file at: ")?;
@@ -232,8 +232,6 @@ fn derive_operation_not_found_error(
     let available_operations: String = available_operations.join(", ");
 
     format!(
-        "The struct name does not match any defined operation in the query file.\nStruct name: {}\nDefined operations: {}",
-        struct_ident,
-        available_operations,
+        "The struct name does not match any defined operation in the query file.\nStruct name: {struct_ident}\nDefined operations: {available_operations}",
     )
 }
diff --git a/graphql_client_codegen/src/query.rs b/graphql_client_codegen/src/query.rs
@@ -260,8 +260,7 @@ where
                     parent.add_to_selection_set(query, id);
                 } else {
                     return Err(QueryValidationError::new(format!(
-                        "Invalid field selection on union field ({:?})",
-                        parent
+                        "Invalid field selection on union field ({parent:?})"
                     )));
                 }
             }
@@ -387,8 +386,7 @@ where
         other => {
             if !selection_set.items.is_empty() {
                 return Err(QueryValidationError::new(format!(
-                    "Selection set on non-object, non-interface type. ({:?})",
-                    other
+                    "Selection set on non-object, non-interface type. ({other:?})"
                 )));
             }
         }
diff --git a/graphql_client_codegen/src/tests/mod.rs b/graphql_client_codegen/src/tests/mod.rs
@@ -117,7 +117,7 @@ fn skip_serializing_none_should_generate_serde_skip_serializing() {
 
     match r {
         Ok(_) => {
-            println!("{}", generated_code);
+            println!("{generated_code}");
             assert!(generated_code.contains("skip_serializing_if"));
         }
         Err(e) => {
diff --git a/graphql_query_derive/src/attributes.rs b/graphql_query_derive/src/attributes.rs
@@ -27,7 +27,7 @@ pub fn ident_exists(ast: &syn::DeriveInput, ident: &str) -> Result<(), syn::Erro
 
     Err(syn::Error::new_spanned(
         ast,
-        format!("Ident `{}` not found", ident),
+        format!("Ident `{ident}` not found"),
     ))
 }
 
@@ -56,7 +56,7 @@ pub fn extract_attr(ast: &syn::DeriveInput, attr: &str) -> Result<String, syn::E
 
     Err(syn::Error::new_spanned(
         ast,
-        format!("Attribute `{}` not found", attr),
+        format!("Attribute `{attr}` not found"),
     ))
 }
 
@@ -184,7 +184,7 @@ mod test {
         let parsed = syn::parse_str(input).unwrap();
         match extract_deprecation_strategy(&parsed) {
             Ok(_) => panic!("parsed unexpectedly"),
-            Err(e) => assert_eq!(&format!("{}", e), DEPRECATION_ERROR),
+            Err(e) => assert_eq!(&format!("{e}"), DEPRECATION_ERROR),
         };
     }
 
diff --git a/graphql_query_derive/src/lib.rs b/graphql_query_derive/src/lib.rs
@@ -32,10 +32,7 @@ fn graphql_query_derive_inner(
     generate_module_token_stream(query_path, &schema_path, options)
         .map(Into::into)
         .map_err(|err| {
-            syn::Error::new_spanned(
-                ast,
-                format!("Failed to generate GraphQLQuery impl: {}", err),
-            )
+            syn::Error::new_spanned(ast, format!("Failed to generate GraphQLQuery impl: {err}"))
         })
 }
 
@@ -48,7 +45,7 @@ fn build_query_and_schema_path(input: &syn::DeriveInput) -> Result<(PathBuf, Pat
     })?;
 
     let query_path = attributes::extract_attr(input, "query_path")?;
-    let query_path = format!("{}/{}", cargo_manifest_dir, query_path);
+    let query_path = format!("{cargo_manifest_dir}/{query_path}");
     let query_path = Path::new(&query_path).to_path_buf();
     let schema_path = attributes::extract_attr(input, "schema_path")?;
     let schema_path = Path::new(&cargo_manifest_dir).join(schema_path);

Original file line number	Diff line number	Diff line change
`@@ -122,8 +122,8 @@ pub enum PathFragment {`
`122`	`122`	`impl Display for PathFragment {`
`123`	`123`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`124`	`124`	`match *self {`
`125`		`- PathFragment::Key(ref key) => write!(f, "{}", key),`
`126`		`- PathFragment::Index(ref idx) => write!(f, "{}", idx),`
	`125`	`+ PathFragment::Key(ref key) => write!(f, "{key}"),`
	`126`	`+ PathFragment::Index(ref idx) => write!(f, "{idx}"),`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`	`}`
`@@ -217,7 +217,7 @@ impl Display for Error {`
`217`	`217`	`fragments`
`218`	`218`	`.iter()`
`219`	`219`	`.fold(String::new(), \|mut acc, item\| {`
`220`		`- let _ = write!(acc, "{}/", item);`
	`220`	`+ let _ = write!(acc, "{item}/");`
`221`	`221`	`acc`
`222`	`222`	`})`
`223`	`223`	`.trim_end_matches('/')`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ fn json_schemas_work_with_and_without_data_field() {`
`33`	`33`	`serde_json::from_value(response).unwrap();`
`34`	`34`
`35`	`35`	`assert_eq!(`
`36`		`- format!("{:?}", schema_1_result),`
	`36`	`+ format!("{schema_1_result:?}"),`
`37`	`37`	`format!("{:?}", schema_2_result)`
`38`	`38`	`);`
`39`	`39`	`}`