feat(cli): add normalize multi-file safety and error aggregation

Author: WendellXY

langcodec-cli/src/main.rs

@@ -223,6 +223,10 @@ enum Commands {
         /// Key renaming style: none|snake|kebab|camel
         #[arg(long, default_value = "none")]
         key_style: String,
+
+        /// Continue processing remaining files when a file fails
+        #[arg(long, default_value_t = false)]
+        continue_on_error: bool,
     },
 
     /// Show translation coverage and per-status counts.
@@ -631,6 +635,7 @@ fn main() {
             check,
             no_placeholders,
             key_style,
+            continue_on_error,
         } => {
             let opts = NormalizeCliOptions {
                 inputs,
@@ -639,6 +644,7 @@ fn main() {
                 check,
                 no_placeholders,
                 key_style,
+                continue_on_error,
             };
             if let Err(e) = run_normalize_command(opts) {
                 eprintln!("❌ Normalize failed: {}", e);

langcodec-cli/src/normalize.rs

@@ -3,6 +3,7 @@ use crate::validation::{validate_file_path, validate_output_path};
 use langcodec::{
     Codec, FormatType, KeyStyle, NormalizeOptions as EngineNormalizeOptions, normalize_codec,
 };
+use std::collections::HashSet;
 use std::path::Path;
 
 #[derive(Debug, Clone)]
@@ -13,6 +14,7 @@ pub struct NormalizeCliOptions {
     pub check: bool,
     pub no_placeholders: bool,
     pub key_style: String,
+    pub continue_on_error: bool,
 }
 
 fn parse_key_style(input: &str) -> Result<KeyStyle, String> {
@@ -68,73 +70,163 @@ fn has_distinct_output_path(input_path: &str, output_path: &Option<String>) -> b
         .is_some_and(|output| Path::new(output) != Path::new(input_path))
 }
 
-pub fn run_normalize_command(opts: NormalizeCliOptions) -> Result<(), String> {
-    let expanded = path_glob::expand_input_globs(&opts.inputs)
-        .map_err(|e| format!("Failed to expand input patterns: {}", e))?;
-    if expanded.is_empty() {
-        return Err("No input files matched the provided patterns".to_string());
-    }
-    if expanded.len() > 1 {
-        return Err("Normalize currently supports exactly one input file".to_string());
-    }
+fn has_glob_meta(input: &str) -> bool {
+    input
+        .bytes()
+        .any(|b| matches!(b, b'*' | b'?' | b'[' | b'{'))
+}
 
-    let input = &expanded[0];
+fn run_normalize_for_file(
+    input: &str,
+    output: &Option<String>,
+    dry_run: bool,
+    check: bool,
+    no_placeholders: bool,
+    key_style: &KeyStyle,
+) -> Result<bool, String> {
     validate_file_path(input)?;
 
     let mut codec = Codec::new();
     codec
         .read_file_by_extension(input, None)
         .map_err(|e| format!("Failed to read input '{}': {}", input, e))?;
 
-    let key_style = parse_key_style(&opts.key_style)?;
     let report = normalize_codec(
         &mut codec,
         &EngineNormalizeOptions {
-            normalize_placeholders: !opts.no_placeholders,
-            key_style,
+            normalize_placeholders: !no_placeholders,
+            key_style: key_style.clone(),
         },
     )
     .map_err(|e| e.to_string())?;
 
-    if opts.check {
+    if check {
         if report.changed {
             println!("would change: {}", input);
             return Err(format!("would change: {}", input));
         }
 
         println!("No changes needed: {}", input);
-        return Ok(());
+        return Ok(false);
     }
 
-    if opts.dry_run {
+    if dry_run {
         if report.changed {
             println!("DRY-RUN: would change {}", input);
+            return Ok(true);
         } else {
             println!("No changes needed: {}", input);
         }
-        return Ok(());
+        return Ok(false);
     }
 
     if !report.changed {
-        if has_distinct_output_path(input, &opts.output) {
-            if let Some(output) = &opts.output {
+        if has_distinct_output_path(input, output) {
+            if let Some(output) = output {
                 validate_output_path(output)?;
             }
-            write_back(&codec, input, &opts.output)?;
+            write_back(&codec, input, output)?;
             println!("No changes needed: {}", input);
-            println!("✅ Wrote output: {}", opts.output.as_deref().unwrap_or(input));
-            return Ok(());
+            println!("✅ Wrote output: {}", output.as_deref().unwrap_or(input));
+            return Ok(false);
         }
 
         println!("No changes needed: {}", input);
-        return Ok(());
+        return Ok(false);
     }
 
-    if let Some(output) = &opts.output {
+    if let Some(output) = output {
         validate_output_path(output)?;
     }
 
-    write_back(&codec, input, &opts.output)?;
-    println!("✅ Normalized: {}", opts.output.as_deref().unwrap_or(input));
-    Ok(())
+    write_back(&codec, input, output)?;
+    println!("✅ Normalized: {}", output.as_deref().unwrap_or(input));
+    Ok(true)
+}
+
+pub fn run_normalize_command(opts: NormalizeCliOptions) -> Result<(), String> {
+    let expanded = path_glob::expand_input_globs(&opts.inputs)
+        .map_err(|e| format!("Failed to expand input patterns: {}", e))?;
+    if expanded.is_empty() {
+        return Err("No input files matched the provided patterns".to_string());
+    }
+
+    if expanded.len() > 1 && opts.output.is_some() {
+        return Err("--output cannot be used with multiple input files".to_string());
+    }
+
+    let key_style = parse_key_style(&opts.key_style)?;
+
+    let mut skip_missing: HashSet<String> = HashSet::new();
+    let mut failures: Vec<String> = Vec::new();
+    let mut processed_count: usize = 0;
+    let mut success_count: usize = 0;
+    let mut failed_count: usize = 0;
+    let mut changed_count: usize = 0;
+
+    for original in &opts.inputs {
+        if !has_glob_meta(original) && !Path::new(original).is_file() {
+            let msg = format!("Input file does not exist: {}", original);
+            if opts.continue_on_error {
+                eprintln!("❌ {}", msg);
+                failures.push(msg);
+                failed_count += 1;
+                skip_missing.insert(original.clone());
+                continue;
+            }
+            return Err(msg);
+        }
+    }
+
+    for input in expanded {
+        if skip_missing.contains(&input) {
+            continue;
+        }
+
+        processed_count += 1;
+
+        match run_normalize_for_file(
+            &input,
+            &opts.output,
+            opts.dry_run,
+            opts.check,
+            opts.no_placeholders,
+            &key_style,
+        ) {
+            Ok(changed) => {
+                success_count += 1;
+                if changed {
+                    changed_count += 1;
+                }
+            }
+            Err(err) => {
+                failed_count += 1;
+                if opts.continue_on_error {
+                    eprintln!("❌ {}", err);
+                    failures.push(err);
+                    continue;
+                }
+
+                println!(
+                    "Summary: processed {}; success: {}; failed: {}; changed: {}",
+                    processed_count, success_count, failed_count, changed_count
+                );
+                return Err(err);
+            }
+        }
+    }
+
+    println!(
+        "Summary: processed {}; success: {}; failed: {}; changed: {}",
+        processed_count, success_count, failed_count, changed_count
+    );
+
+    if failures.is_empty() {
+        return Ok(());
+    }
+
+    Err(format!(
+        "{} file(s) failed. See errors above.",
+        failures.len()
+    ))
 }

langcodec-cli/tests/normalize_cli_tests.rs

@@ -162,3 +162,73 @@ fn test_normalize_check_and_dry_run_with_output_do_not_create_directories() {
         );
     }
 }
+
+#[test]
+fn test_normalize_rejects_output_with_multiple_inputs() {
+    let temp_dir = TempDir::new().unwrap();
+    let input_a = temp_dir.path().join("a.strings");
+    let input_b = temp_dir.path().join("b.strings");
+    let output_path = temp_dir.path().join("out.strings");
+    fs::write(&input_a, "\"a\" = \"A\";\n").unwrap();
+    fs::write(&input_b, "\"b\" = \"B\";\n").unwrap();
+
+    let output = langcodec_cmd()
+        .args([
+            "normalize",
+            "-i",
+            input_a.to_str().unwrap(),
+            input_b.to_str().unwrap(),
+            "-o",
+            output_path.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+
+    assert!(!output.status.success());
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert!(
+        combined.contains("--output cannot be used with multiple input files"),
+        "expected --output multi-input rejection; got: {combined}"
+    );
+}
+
+#[test]
+fn test_normalize_continue_on_error_aggregates_and_returns_non_zero() {
+    let temp_dir = TempDir::new().unwrap();
+    let good = temp_dir.path().join("good.strings");
+    let bad = temp_dir.path().join("bad.txt");
+    fs::write(&good, "\"z\" = \"%@\";\n\"a\" = \"A\";\n").unwrap();
+    fs::write(&bad, "not a supported localization format").unwrap();
+
+    let output = langcodec_cmd()
+        .args([
+            "normalize",
+            "-i",
+            bad.to_str().unwrap(),
+            good.to_str().unwrap(),
+            "--continue-on-error",
+        ])
+        .output()
+        .unwrap();
+
+    assert!(
+        !output.status.success(),
+        "expected non-zero when at least one file fails"
+    );
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let combined = format!("{stdout}{stderr}");
+
+    assert!(
+        combined.contains("Summary: processed 2; success: 1; failed: 1"),
+        "expected summary counts, got: {combined}"
+    );
+    assert!(
+        combined.contains("✅ Normalized:"),
+        "expected successful file processing to continue, got: {combined}"
+    );
+}