feat(cli): implement normalize check and dry-run semantics

Author: WendellXY

langcodec-cli/src/main.rs

@@ -17,7 +17,7 @@ use crate::debug::run_debug_command;
 use crate::diff::{DiffOptions, run_diff_command};
 use crate::edit::{EditSetOptions, run_edit_set_command};
 use crate::merge::{ConflictStrategy, run_merge_command};
-use crate::normalize::run_normalize_command;
+use crate::normalize::{NormalizeCliOptions, run_normalize_command};
 use crate::sync::{SyncOptions, run_sync_command};
 use crate::validation::{ValidationContext, validate_context, validate_language_code};
 use crate::view::print_view;
@@ -199,7 +199,31 @@ enum Commands {
     },
 
     /// Normalize localization files.
-    Normalize,
+    Normalize {
+        /// The input files to normalize (supports glob patterns). Quote patterns to avoid shell expansion.
+        #[arg(short, long, num_args = 1.., help = "Input files. Supports glob patterns. Quote patterns to avoid slow shell-side expansion (e.g., '/path/**/*/Localizable.strings').")]
+        inputs: Vec<String>,
+
+        /// Optional output file (single-file mode only). If omitted, writes in-place.
+        #[arg(short, long)]
+        output: Option<String>,
+
+        /// Preview changes without writing
+        #[arg(long, default_value_t = false)]
+        dry_run: bool,
+
+        /// Exit non-zero if normalization would change the file
+        #[arg(long, default_value_t = false)]
+        check: bool,
+
+        /// Disable placeholder normalization
+        #[arg(long, default_value_t = false)]
+        no_placeholders: bool,
+
+        /// Key renaming style: none|snake|kebab|camel
+        #[arg(long, default_value = "none")]
+        key_style: String,
+    },
 
     /// Show translation coverage and per-status counts.
     Stats {
@@ -600,8 +624,23 @@ fn main() {
             cmd = cmd.bin_name("langcodec");
             generate(shell, &mut cmd, "langcodec", &mut std::io::stdout());
         }
-        Commands::Normalize => {
-            if let Err(e) = run_normalize_command() {
+        Commands::Normalize {
+            inputs,
+            output,
+            dry_run,
+            check,
+            no_placeholders,
+            key_style,
+        } => {
+            let opts = NormalizeCliOptions {
+                inputs,
+                output,
+                dry_run,
+                check,
+                no_placeholders,
+                key_style,
+            };
+            if let Err(e) = run_normalize_command(opts) {
                 eprintln!("❌ Normalize failed: {}", e);
                 std::process::exit(1);
             }

langcodec-cli/src/normalize.rs

@@ -1,4 +1,113 @@
-/// Temporary scaffold for Task 1; normalize behavior will be implemented in later tasks.
-pub fn run_normalize_command() -> Result<(), String> {
+use crate::path_glob;
+use crate::validation::{validate_file_path, validate_output_path};
+use langcodec::{
+    Codec, FormatType, KeyStyle, NormalizeOptions as EngineNormalizeOptions, normalize_codec,
+};
+
+#[derive(Debug, Clone)]
+pub struct NormalizeCliOptions {
+    pub inputs: Vec<String>,
+    pub output: Option<String>,
+    pub dry_run: bool,
+    pub check: bool,
+    pub no_placeholders: bool,
+    pub key_style: String,
+}
+
+fn parse_key_style(input: &str) -> Result<KeyStyle, String> {
+    match input.trim().to_ascii_lowercase().as_str() {
+        "none" => Ok(KeyStyle::None),
+        "snake" => Ok(KeyStyle::Snake),
+        "kebab" => Ok(KeyStyle::Kebab),
+        "camel" => Ok(KeyStyle::Camel),
+        other => Err(format!(
+            "Invalid --key-style '{}'. Expected one of: none, snake, kebab, camel",
+            other
+        )),
+    }
+}
+
+fn infer_output_format_from_path(path: &str) -> Result<FormatType, String> {
+    langcodec::infer_format_from_extension(path)
+        .ok_or_else(|| format!("Cannot infer format from path: {}", path))
+}
+
+fn pick_single_resource(codec: &Codec) -> Result<&langcodec::Resource, String> {
+    if codec.resources.len() == 1 {
+        Ok(&codec.resources[0])
+    } else {
+        Err(
+            "Multiple languages present; single-language output requires exactly one resource"
+                .to_string(),
+        )
+    }
+}
+
+fn write_back(codec: &Codec, input_path: &str, output_path: &Option<String>) -> Result<(), String> {
+    let input_owned = input_path.to_string();
+    let out = output_path.as_ref().unwrap_or(&input_owned);
+    let fmt = infer_output_format_from_path(out)?;
+
+    match fmt {
+        FormatType::Strings(_) | FormatType::AndroidStrings(_) => {
+            let resource = pick_single_resource(codec)?;
+            Codec::write_resource_to_file(resource, out)
+                .map_err(|e| format!("Error writing output: {}", e))
+        }
+        FormatType::Xcstrings | FormatType::CSV | FormatType::TSV => {
+            langcodec::converter::convert_resources_to_format(codec.resources.clone(), out, fmt)
+                .map_err(|e| format!("Error writing output: {}", e))
+        }
+    }
+}
+
+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());
+    }
+
+    let input = &expanded[0];
+    validate_file_path(input)?;
+    if let Some(output) = &opts.output {
+        validate_output_path(output)?;
+    }
+
+    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,
+        },
+    )
+    .map_err(|e| e.to_string())?;
+
+    if !report.changed {
+        println!("No changes needed: {}", input);
+        return Ok(());
+    }
+
+    if opts.check {
+        println!("would change: {}", input);
+        return Err(format!("would change: {}", input));
+    }
+
+    if opts.dry_run {
+        println!("DRY-RUN: would change {}", input);
+        return Ok(());
+    }
+
+    write_back(&codec, input, &opts.output)?;
+    println!("✅ Normalized: {}", opts.output.as_deref().unwrap_or(input));
     Ok(())
 }

langcodec-cli/tests/normalize_cli_tests.rs

@@ -1,4 +1,6 @@
+use std::fs;
 use std::process::Command;
+use tempfile::TempDir;
 
 fn langcodec_cmd() -> Command {
     Command::new(assert_cmd::cargo::cargo_bin!("langcodec"))
@@ -14,12 +16,66 @@ fn test_main_help_lists_normalize() {
 
 #[test]
 fn test_normalize_command_executes_successfully() {
-    let output = langcodec_cmd().args(["normalize"]).output().unwrap();
+    let temp_dir = TempDir::new().unwrap();
+    let input = temp_dir.path().join("en.strings");
+    fs::write(&input, "\"a\" = \"A\";\n\"b\" = \"B\";\n").unwrap();
+
+    let output = langcodec_cmd()
+        .args(["normalize", "-i", input.to_str().unwrap()])
+        .output()
+        .unwrap();
     let stderr = String::from_utf8_lossy(&output.stderr);
 
     assert!(
         output.status.success(),
         "normalize command failed with stderr: {stderr}"
     );
-    assert!(!stderr.contains("panicked at"), "normalize command panicked");
+    assert!(
+        !stderr.contains("panicked at"),
+        "normalize command panicked"
+    );
+}
+
+#[test]
+fn test_normalize_check_fails_on_drift() {
+    let temp_dir = TempDir::new().unwrap();
+    let input = temp_dir.path().join("en.strings");
+    fs::write(&input, "\"z\" = \"%@\";\n\"a\" = \"A\";\n").unwrap();
+
+    let output = langcodec_cmd()
+        .args(["normalize", "-i", input.to_str().unwrap(), "--check"])
+        .output()
+        .unwrap();
+
+    assert!(!output.status.success());
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert!(
+        combined.contains("would change"),
+        "expected output to mention drift; got: {combined}"
+    );
+}
+
+#[test]
+fn test_normalize_dry_run_does_not_write() {
+    let temp_dir = TempDir::new().unwrap();
+    let input = temp_dir.path().join("en.strings");
+    let before = "\"z\" = \"%@\";\n\"a\" = \"A\";\n";
+    fs::write(&input, before).unwrap();
+
+    let output = langcodec_cmd()
+        .args(["normalize", "-i", input.to_str().unwrap(), "--dry-run"])
+        .output()
+        .unwrap();
+
+    assert!(
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let after = fs::read_to_string(&input).unwrap();
+    assert_eq!(after, before);
 }