Fix Clippy warnings after updating the local Rust toolchain

Refactored several modules to use Rust's let-chains for more concise and readable pattern matching, replacing nested if-let and match statements. This change affects format detection, merge logic, validation, test cases, and language inference, improving code clarity and reducing nesting.

Author: WendellXY

langcodec-cli/src/formats.rs

@@ -126,16 +126,16 @@ pub fn detect_custom_format(file_path: &str, file_content: &str) -> Option<Custo
             // Try to parse as JSON array of Resource objects
             if serde_json::from_str::<Vec<serde_json::Value>>(file_content).is_ok() {
                 // Check if it looks like an array of Resource objects
-                if let Ok(array) = serde_json::from_str::<Vec<serde_json::Value>>(file_content) {
-                    if !array.is_empty() {
-                        // Check if the first element has the expected Resource structure
-                        if let Some(first) = array.first() {
-                            if let Some(obj) = first.as_object() {
-                                if obj.contains_key("metadata") && obj.contains_key("entries") {
-                                    return Some(CustomFormat::LangcodecResourceArray);
-                                }
-                            }
-                        }
+                if let Ok(array) = serde_json::from_str::<Vec<serde_json::Value>>(file_content)
+                    && !array.is_empty()
+                {
+                    // Check if the first element has the expected Resource structure
+                    if let Some(first) = array.first()
+                        && let Some(obj) = first.as_object()
+                        && obj.contains_key("metadata")
+                        && obj.contains_key("entries")
+                    {
+                        return Some(CustomFormat::LangcodecResourceArray);
                     }
                 }
             }
@@ -147,10 +147,9 @@ pub fn detect_custom_format(file_path: &str, file_content: &str) -> Option<Custo
                 if let Ok(obj) = serde_json::from_str::<
                     std::collections::HashMap<String, serde_json::Value>,
                 >(file_content)
+                    && !obj.is_empty()
                 {
-                    if !obj.is_empty() {
-                        return Some(CustomFormat::JSONLanguageMap);
-                    }
+                    return Some(CustomFormat::JSONLanguageMap);
                 }
                 // Check if it's an array (JSONArrayLanguageMap)
                 if serde_json::from_str::<Vec<serde_json::Value>>(file_content).is_ok() {

langcodec-cli/src/merge.rs

@@ -37,10 +37,10 @@ pub fn run_merge_command(
         }
 
         // If standard format fails, try custom format for JSON/YAML files
-        if input.ends_with(".json") || input.ends_with(".yaml") || input.ends_with(".yml") {
-            if let Ok(()) = try_custom_format_merge(input, lang.clone(), &mut codec) {
-                continue;
-            }
+        if (input.ends_with(".json") || input.ends_with(".yaml") || input.ends_with(".yml"))
+            && let Ok(()) = try_custom_format_merge(input, lang.clone(), &mut codec)
+        {
+            continue;
         }
 
         // If both fail, show error
@@ -111,12 +111,12 @@ pub fn run_merge_command(
         None => {
             if codec.resources.len() == 1 {
                 println!("Writing single resource to output file");
-                if let Some(resource) = codec.resources.first() {
-                    if let Err(e) = Codec::write_resource_to_file(resource, &output) {
-                        println!("❌ Error writing output file");
-                        eprintln!("Error writing to {}: {}", output, e);
-                        std::process::exit(1);
-                    }
+                if let Some(resource) = codec.resources.first()
+                    && let Err(e) = Codec::write_resource_to_file(resource, &output)
+                {
+                    println!("❌ Error writing output file");
+                    eprintln!("Error writing to {}: {}", output, e);
+                    std::process::exit(1);
                 }
             } else {
                 println!("❌ Error writing output file");

langcodec-cli/src/validation.rs

@@ -77,12 +77,12 @@ pub fn validate_file_path(path: &str) -> Result<(), String> {
 pub fn validate_output_path(path: &str) -> Result<(), String> {
     let path_obj = Path::new(path);
 
-    if let Some(parent) = path_obj.parent() {
-        if !parent.exists() {
-            // Try to create the directory
-            if let Err(e) = std::fs::create_dir_all(parent) {
-                return Err(format!("Cannot create output directory: {}", e));
-            }
+    if let Some(parent) = path_obj.parent()
+        && !parent.exists()
+    {
+        // Try to create the directory
+        if let Err(e) = std::fs::create_dir_all(parent) {
+            return Err(format!("Cannot create output directory: {}", e));
         }
     }
 

langcodec-cli/tests/format_edge_cases.rs

@@ -69,12 +69,10 @@ fn test_json_with_null_values() {
         CustomFormat::JSONLanguageMap,
     );
 
-    // Should handle null values gracefully
-    if result.is_ok() {
-        let resources = result.unwrap();
-        let fr_resource = resources.iter().find(|r| r.metadata.language == "fr");
-        assert!(fr_resource.is_none() || fr_resource.unwrap().entries.is_empty());
-    }
+    // Should fail because null values are not supported
+    assert!(result.is_err());
+    let error = result.unwrap_err();
+    assert!(error.contains("Error parsing JSON") || error.contains("Invalid format"));
 }
 
 #[test]
@@ -96,8 +94,7 @@ fn test_json_with_boolean_values() {
     );
 
     // Should convert booleans to strings
-    if result.is_ok() {
-        let resources = result.unwrap();
+    if let Ok(resources) = result {
         let en_resource = resources
             .iter()
             .find(|r| r.metadata.language == "en")
@@ -128,8 +125,7 @@ fn test_json_with_numbers() {
     );
 
     // Should convert numbers to strings
-    if result.is_ok() {
-        let resources = result.unwrap();
+    if let Ok(resources) = result {
         let en_resource = resources
             .iter()
             .find(|r| r.metadata.language == "en")
@@ -206,8 +202,7 @@ fn test_json_array_with_missing_keys() {
     );
 
     // Should handle missing keys gracefully
-    if result.is_ok() {
-        let resources = result.unwrap();
+    if let Ok(resources) = result {
         assert_eq!(resources.len(), 2); // en and fr
     }
 }
@@ -238,8 +233,7 @@ fn test_json_array_with_duplicate_keys() {
     );
 
     // Should handle duplicate keys (last one wins)
-    if result.is_ok() {
-        let resources = result.unwrap();
+    if let Ok(resources) = result {
         let en_resource = resources
             .iter()
             .find(|r| r.metadata.language == "en")

langcodec/src/codec.rs

@@ -68,12 +68,12 @@ impl Codec {
     }
 
     /// Returns an iterator over all resources.
-    pub fn iter(&self) -> std::slice::Iter<Resource> {
+    pub fn iter(&self) -> std::slice::Iter<'_, Resource> {
         self.resources.iter()
     }
 
     /// Returns a mutable iterator over all resources.
-    pub fn iter_mut(&mut self) -> std::slice::IterMut<Resource> {
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, Resource> {
         self.resources.iter_mut()
     }
 

langcodec/src/converter.rs

@@ -372,21 +372,19 @@ pub fn infer_language_from_path<P: AsRef<Path>>(
             if let Some(captures) = regex::Regex::new(r"([a-z]{2}(?:-[A-Z]{2})?)\.lproj")
                 .map_err(|_| Error::InvalidResource("Invalid regex pattern".to_string()))?
                 .captures(&path_str)
+                && let Some(lang) = captures.get(1)
             {
-                if let Some(lang) = captures.get(1) {
-                    return Ok(Some(lang.as_str().to_string()));
-                }
+                return Ok(Some(lang.as_str().to_string()));
             }
         }
         FormatType::AndroidStrings(_) => {
             // Android strings.xml files: values-es/strings.xml
             if let Some(captures) = regex::Regex::new(r"values-([a-z]{2}(?:-[A-Z]{2})?)")
                 .map_err(|_| Error::InvalidResource("Invalid regex pattern".to_string()))?
                 .captures(&path_str)
+                && let Some(lang) = captures.get(1)
             {
-                if let Some(lang) = captures.get(1) {
-                    return Ok(Some(lang.as_str().to_string()));
-                }
+                return Ok(Some(lang.as_str().to_string()));
             }
         }
         _ => {}