fix uninlined format args

Author: Jiloc

contrib/tools/config-docs-generator/src/extract_docs.rs

@@ -134,7 +134,7 @@ fn main() -> Result<()> {
     // Write the extracted docs to file
     fs::write(output_file, serde_json::to_string_pretty(&config_docs)?)?;
 
-    println!("Successfully extracted documentation to {}", output_file);
+    println!("Successfully extracted documentation to {output_file}");
     println!(
         "Found {} structs with documentation",
         config_docs.structs.len()
@@ -184,8 +184,7 @@ fn generate_rustdoc_json(package: &str) -> Result<serde_json::Value> {
     // Generate rustdoc for additional crates that might contain referenced constants
     for additional_crate in &additional_crates {
         let error_msg = format!(
-            "Failed to run cargo rustdoc command for {}",
-            additional_crate
+            "Failed to run cargo rustdoc command for {additional_crate}"
         );
         let output = StdCommand::new("cargo")
             .args([
@@ -209,8 +208,7 @@ fn generate_rustdoc_json(package: &str) -> Result<serde_json::Value> {
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
             eprintln!(
-                "Warning: Failed to generate rustdoc for {}: {}",
-                additional_crate, stderr
+                "Warning: Failed to generate rustdoc for {additional_crate}: {stderr}"
             );
         }
     }
@@ -225,7 +223,7 @@ fn generate_rustdoc_json(package: &str) -> Result<serde_json::Value> {
     };
 
     // Read the generated JSON file - rustdoc generates it based on library name
-    let json_file_path = format!("{}/doc/{}.json", rustdoc_target_dir, lib_name);
+    let json_file_path = format!("{rustdoc_target_dir}/doc/{lib_name}.json");
     let json_content = std::fs::read_to_string(json_file_path)
         .context("Failed to read generated rustdoc JSON file")?;
 
@@ -464,8 +462,7 @@ fn parse_field_documentation(
                 "" => false, // Empty string defaults to false
                 text => text.parse::<bool>().unwrap_or_else(|_| {
                     eprintln!(
-                        "Warning: Invalid @required value '{}' for field '{}', defaulting to false",
-                        text, field_name
+                        "Warning: Invalid @required value '{text}' for field '{field_name}', defaulting to false"
                     );
                     false
                 }),
@@ -632,14 +629,14 @@ fn parse_folded_block_scalar(lines: &[&str], _base_indent: usize) -> String {
     // Remove trailing empty lines but preserve a single trailing newline if content exists
     let trimmed = result.trim_end_matches('\n');
     if !trimmed.is_empty() && result.ends_with('\n') {
-        format!("{}\n", trimmed)
+        format!("{trimmed}\n")
     } else {
         trimmed.to_string()
     }
 }
 
 fn extract_annotation(metadata_section: &str, annotation_name: &str) -> Option<String> {
-    let annotation_pattern = format!("@{}:", annotation_name);
+    let annotation_pattern = format!("@{annotation_name}:");
 
     if let Some(_start_pos) = metadata_section.find(&annotation_pattern) {
         // Split the metadata section into lines for processing
@@ -820,7 +817,7 @@ fn resolve_constant_reference(
     let additional_crate_libs = ["stacks_common"]; // Library names for additional crates
 
     for lib_name in &additional_crate_libs {
-        let json_file_path = format!("target/rustdoc-json/doc/{}.json", lib_name);
+        let json_file_path = format!("target/rustdoc-json/doc/{lib_name}.json");
         if let Ok(json_content) = std::fs::read_to_string(&json_file_path) {
             if let Ok(rustdoc_json) = serde_json::from_str::<serde_json::Value>(&json_content) {
                 if let Some(index) = get_json_object(&rustdoc_json, &["index"]) {

contrib/tools/config-docs-generator/src/generate_markdown.rs

@@ -103,7 +103,7 @@ fn main() -> Result<()> {
     let mappings_path = matches.get_one::<String>("mappings").unwrap();
 
     let input_content = fs::read_to_string(input_path)
-        .with_context(|| format!("Failed to read input JSON file: {}", input_path))?;
+        .with_context(|| format!("Failed to read input JSON file: {input_path}"))?;
 
     let config_docs: ConfigDocs =
         serde_json::from_str(&input_content).with_context(|| "Failed to parse input JSON")?;
@@ -113,27 +113,24 @@ fn main() -> Result<()> {
     let markdown = generate_markdown(&config_docs, template_path, &custom_mappings)?;
 
     fs::write(output_path, markdown)
-        .with_context(|| format!("Failed to write output file: {}", output_path))?;
+        .with_context(|| format!("Failed to write output file: {output_path}"))?;
 
     println!(
-        "Successfully generated Markdown documentation at {}",
-        output_path
+        "Successfully generated Markdown documentation at {output_path}"
     );
     Ok(())
 }
 
 fn load_section_name_mappings(mappings_file: &str) -> Result<HashMap<String, String>> {
     let content = fs::read_to_string(mappings_file).with_context(|| {
         format!(
-            "Failed to read section name mappings file: {}",
-            mappings_file
+            "Failed to read section name mappings file: {mappings_file}"
         )
     })?;
 
     let mappings: HashMap<String, String> = serde_json::from_str(&content).with_context(|| {
         format!(
-            "Failed to parse section name mappings JSON: {}",
-            mappings_file
+            "Failed to parse section name mappings JSON: {mappings_file}"
         )
     })?;
 
@@ -142,14 +139,14 @@ fn load_section_name_mappings(mappings_file: &str) -> Result<HashMap<String, Str
 
 fn load_template(template_path: &str) -> Result<String> {
     fs::read_to_string(template_path)
-        .with_context(|| format!("Failed to read template file: {}", template_path))
+        .with_context(|| format!("Failed to read template file: {template_path}"))
 }
 
 fn render_template(template: &str, variables: HashMap<String, String>) -> String {
     let mut result = template.to_string();
 
     for (key, value) in variables {
-        let placeholder = format!("{{{{{}}}}}", key);
+        let placeholder = format!("{{{{{key}}}}}");
         result = result.replace(&placeholder, &value);
     }
 
@@ -245,7 +242,7 @@ fn generate_struct_section(
     custom_mappings: &HashMap<String, String>,
 ) -> Result<()> {
     let section_name = struct_to_section_name(&struct_doc.name, custom_mappings);
-    output.push_str(&format!("## {}\n\n", section_name));
+    output.push_str(&format!("## {section_name}\n\n"));
 
     // Add struct description if available
     if let Some(description) = &struct_doc.description {
@@ -365,7 +362,7 @@ fn generate_field_row(
 
     // Add deprecation warning if present
     if let Some(deprecated) = &field.deprecated {
-        description_parts.push(format!("<br><br>**⚠️ DEPRECATED:** {}", deprecated));
+        description_parts.push(format!("<br><br>**⚠️ DEPRECATED:** {deprecated}"));
     }
 
     // Add TOML example if present
@@ -385,16 +382,15 @@ fn generate_field_row(
             .replace('\n', "&#10;"); // Use HTML entity for newline to avoid <br> conversion
 
         let example_section = format!(
-            "<br><br>**Example:**<br><pre><code>{}</code></pre>",
-            escaped_example // HTML entities will be rendered as newlines by <pre>
+            "<br><br>**Example:**<br><pre><code>{escaped_example}</code></pre>" // HTML entities will be rendered as newlines by <pre>
         );
         description_parts.push(example_section);
     }
 
     // Add units information if present
     if let Some(units) = &field.units {
         let units_text = process_intralinks_with_context(units, global_context, struct_name);
-        description_parts.push(format!("<br><br>**Units:** {}", units_text));
+        description_parts.push(format!("<br><br>**Units:** {units_text}"));
     }
 
     let description = if description_parts.is_empty() {
@@ -513,11 +509,11 @@ fn process_reference(
                 // Check if it's the same struct or different struct
                 if ref_struct_name == current_struct_name {
                     // Same struct: just show field name
-                    return format!("[{}](#{}) ", field_name, anchor_id);
+                    return format!("[{field_name}](#{anchor_id}) ");
                 } else {
                     // Different struct: show [config_section].field_name as a link
                     let config_section = section_name.trim_start_matches('[').trim_end_matches(']');
-                    return format!("[[{}].{}](#{}) ", config_section, field_name, anchor_id);
+                    return format!("[[{config_section}].{field_name}](#{anchor_id}) ");
                 }
             }
         }
@@ -540,11 +536,11 @@ fn process_reference(
             // Check if it's the same struct or different struct
             if field_struct_name == current_struct_name {
                 // Same struct: just show field name
-                return format!("[{}](#{}) ", reference, anchor_id);
+                return format!("[{reference}](#{anchor_id}) ");
             } else {
                 // Different struct: show [config_section].field_name as a link
                 let config_section = section_name.trim_start_matches('[').trim_end_matches(']');
-                return format!("[[{}].{}](#{}) ", config_section, reference, anchor_id);
+                return format!("[[{config_section}].{reference}](#{anchor_id}) ");
             }
         }
     }
@@ -577,7 +573,7 @@ fn process_hierarchical_lists(
             let processed_content =
                 process_intralinks_with_context(content, global_context, struct_name);
 
-            result.push(format!("{}{}", indent_html, processed_content));
+            result.push(format!("{indent_html}{processed_content}"));
         } else {
             // Process intra-links in non-bullet lines too
             let processed_line = process_intralinks_with_context(line, global_context, struct_name);