fix: resolve all compiler warnings and format code

- Add #[allow(dead_code)] attributes for ABI spec fields that are parsed but not displayed
- Fix code formatting with cargo fmt
- Maintain full ABI spec compatibility while suppressing unused field warnings

Author: devdotbo

src/abi.rs

@@ -5,15 +5,19 @@ pub struct AbiInput {
     pub name: Option<String>,
     pub r#type: String,
     pub indexed: Option<bool>,
+    #[allow(dead_code)]
     pub internal_type: Option<String>,
+    #[allow(dead_code)]
     pub components: Option<Vec<AbiInput>>,
 }
 
 #[derive(Debug, Clone)]
 pub struct AbiOutput {
     pub name: Option<String>,
     pub r#type: String,
+    #[allow(dead_code)]
     pub internal_type: Option<String>,
+    #[allow(dead_code)]
     pub components: Option<Vec<AbiOutput>>,
 }
 
@@ -24,8 +28,11 @@ pub struct AbiItem {
     pub inputs: Option<Vec<AbiInput>>,
     pub outputs: Option<Vec<AbiOutput>>,
     pub state_mutability: Option<String>,
+    #[allow(dead_code)]
     pub anonymous: Option<bool>,
+    #[allow(dead_code)]
     pub payable: Option<bool>,
+    #[allow(dead_code)]
     pub constant: Option<bool>,
 }
 
@@ -36,9 +43,12 @@ impl fmt::Display for AbiItem {
 
         match type_str.as_str() {
             "constructor" => {
-                let params = self.inputs.as_ref()
+                let params = self
+                    .inputs
+                    .as_ref()
                     .map(|inputs| {
-                        inputs.iter()
+                        inputs
+                            .iter()
                             .map(|p| {
                                 if let Some(name) = &p.name {
                                     format!("{} {}", p.r#type, name)
@@ -53,9 +63,12 @@ impl fmt::Display for AbiItem {
                 write!(f, "constructor({})", params)
             }
             "event" => {
-                let params = self.inputs.as_ref()
+                let params = self
+                    .inputs
+                    .as_ref()
                     .map(|inputs| {
-                        inputs.iter()
+                        inputs
+                            .iter()
                             .map(|p| {
                                 let indexed = if p.indexed.unwrap_or(false) {
                                     " indexed"
@@ -72,12 +85,20 @@ impl fmt::Display for AbiItem {
                             .join(", ")
                     })
                     .unwrap_or_default();
-                write!(f, "event {}({})", self.name.as_ref().unwrap_or(&String::new()), params)
+                write!(
+                    f,
+                    "event {}({})",
+                    self.name.as_ref().unwrap_or(&String::new()),
+                    params
+                )
             }
             "function" => {
-                let params = self.inputs.as_ref()
+                let params = self
+                    .inputs
+                    .as_ref()
                     .map(|inputs| {
-                        inputs.iter()
+                        inputs
+                            .iter()
                             .map(|p| {
                                 if let Some(name) = &p.name {
                                     format!("{} {}", p.r#type, name)
@@ -89,10 +110,11 @@ impl fmt::Display for AbiItem {
                             .join(", ")
                     })
                     .unwrap_or_default();
-                
+
                 let returns = if let Some(outputs) = &self.outputs {
                     if !outputs.is_empty() {
-                        let output_params = outputs.iter()
+                        let output_params = outputs
+                            .iter()
                             .map(|o| {
                                 let has_name = o.name.as_ref().map_or(false, |n| !n.is_empty());
                                 if has_name {
@@ -117,11 +139,14 @@ impl fmt::Display for AbiItem {
                     String::new()
                 };
 
-                write!(f, "function {}({}){}{}", 
-                    self.name.as_ref().unwrap_or(&String::new()), 
-                    params, 
-                    vis, 
-                    returns)
+                write!(
+                    f,
+                    "function {}({}){}{}",
+                    self.name.as_ref().unwrap_or(&String::new()),
+                    params,
+                    vis,
+                    returns
+                )
             }
             "fallback" => {
                 let payable = if visibility == "payable" {
@@ -139,4 +164,4 @@ impl fmt::Display for AbiItem {
             }
         }
     }
-}
+}

src/converter.rs

@@ -11,9 +11,7 @@ impl Converter {
 
     pub fn convert_to_human_readable(abi: &[AbiItem]) -> Vec<String> {
         abi.iter()
-            .filter(|item| {
-                !item.r#type.is_empty() && item.r#type != "unknown"
-            })
+            .filter(|item| !item.r#type.is_empty() && item.r#type != "unknown")
             .map(|item| item.to_string())
             .filter(|formatted| !formatted.is_empty() && !formatted.starts_with("{}"))
             .collect()
@@ -48,7 +46,8 @@ fn format_json_pretty(strings: &[String]) -> String {
 }
 
 fn format_json_compact(strings: &[String]) -> String {
-    let escaped: Vec<String> = strings.iter()
+    let escaped: Vec<String> = strings
+        .iter()
         .map(|s| format!("\"{}\"", escape_json_string(s)))
         .collect();
     format!("[{}]", escaped.join(","))
@@ -70,4 +69,4 @@ fn escape_json_string(s: &str) -> String {
         }
     }
     result
-}
+}

src/file_ops.rs

@@ -1,7 +1,7 @@
+use crate::converter::Converter;
 use std::fs;
-use std::path::{Path, PathBuf};
 use std::io::{self, Read, Write};
-use crate::converter::Converter;
+use std::path::{Path, PathBuf};
 
 pub struct ConvertOptions {
     pub suffix: String,
@@ -75,7 +75,8 @@ pub fn convert_file(
         path.to_path_buf()
     } else {
         let mut path = input_path.to_path_buf();
-        let stem = path.file_stem()
+        let stem = path
+            .file_stem()
             .and_then(|s| s.to_str())
             .unwrap_or("output");
         let new_name = format!("{}{}.json", stem, options.suffix);
@@ -138,7 +139,7 @@ pub fn convert_directory(
 
     for entry in entries.filter_map(Result::ok) {
         let path = entry.path();
-        
+
         if path.is_file() {
             if let Some(ext) = path.extension() {
                 if ext == "json" {
@@ -152,10 +153,9 @@ pub fn convert_directory(
                         }
                     }
 
-                    let relative = path.strip_prefix(input_dir)
-                        .unwrap_or(&path);
+                    let relative = path.strip_prefix(input_dir).unwrap_or(&path);
                     let output_path = output_dir.join(relative);
-                    
+
                     results.push(convert_file(&path, Some(&output_path), options));
                 }
             }
@@ -190,20 +190,20 @@ pub fn convert_stdin_to_stdout(options: &ConvertOptions) -> io::Result<()> {
 
 fn matches_pattern(filename: &str, pattern: &str) -> bool {
     let pattern_parts: Vec<&str> = pattern.split('*').collect();
-    
+
     if pattern_parts.is_empty() {
         return true;
     }
 
     let mut filename_pos = 0;
-    
+
     for (i, part) in pattern_parts.iter().enumerate() {
         if part.is_empty() {
             if i == 0 || i == pattern_parts.len() - 1 {
                 continue;
             }
         }
-        
+
         if let Some(pos) = filename[filename_pos..].find(part) {
             filename_pos += pos + part.len();
         } else {
@@ -216,4 +216,4 @@ fn matches_pattern(filename: &str, pattern: &str) -> bool {
     }
 
     true
-}
+}