fix(cli): honor strict normalize and handle unmatched globs

Author: WendellXY

langcodec-cli/src/main.rs

@@ -645,6 +645,7 @@ fn main() {
                 no_placeholders,
                 key_style,
                 continue_on_error,
+                strict,
             };
             if let Err(e) = run_normalize_command(opts) {
                 eprintln!("❌ Normalize failed: {}", e);

langcodec-cli/src/normalize.rs

@@ -1,7 +1,8 @@
 use crate::path_glob;
 use crate::validation::{validate_file_path, validate_output_path};
 use langcodec::{
-    Codec, FormatType, KeyStyle, NormalizeOptions as EngineNormalizeOptions, normalize_codec,
+    Codec, FormatType, KeyStyle, NormalizeOptions as EngineNormalizeOptions, ReadOptions,
+    normalize_codec,
 };
 use std::collections::HashSet;
 use std::path::Path;
@@ -15,6 +16,7 @@ pub struct NormalizeCliOptions {
     pub no_placeholders: bool,
     pub key_style: String,
     pub continue_on_error: bool,
+    pub strict: bool,
 }
 
 fn parse_key_style(input: &str) -> Result<KeyStyle, String> {
@@ -83,19 +85,20 @@ fn run_normalize_for_file(
     check: bool,
     no_placeholders: bool,
     key_style: &KeyStyle,
+    strict: bool,
 ) -> Result<bool, String> {
     validate_file_path(input)?;
 
     let mut codec = Codec::new();
     codec
-        .read_file_by_extension(input, None)
+        .read_file_by_extension_with_options(input, &ReadOptions::new().with_strict(strict))
         .map_err(|e| format!("Failed to read input '{}': {}", input, e))?;
 
     let report = normalize_codec(
         &mut codec,
         &EngineNormalizeOptions {
             normalize_placeholders: !no_placeholders,
-            key_style: key_style.clone(),
+            key_style: *key_style,
         },
     )
     .map_err(|e| e.to_string())?;
@@ -147,6 +150,10 @@ fn run_normalize_for_file(
 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))?;
+    let expanded: Vec<String> = expanded
+        .into_iter()
+        .filter(|path| !has_glob_meta(path) || Path::new(path).is_file())
+        .collect();
     if expanded.is_empty() {
         return Err("No input files matched the provided patterns".to_string());
     }
@@ -193,6 +200,7 @@ pub fn run_normalize_command(opts: NormalizeCliOptions) -> Result<(), String> {
             opts.check,
             opts.no_placeholders,
             &key_style,
+            opts.strict,
         ) {
             Ok(changed) => {
                 success_count += 1;

langcodec-cli/tests/normalize_cli_tests.rs

@@ -347,3 +347,54 @@ fn test_normalize_continue_on_error_counts_literal_missing_input_in_summary() {
         "expected coherent summary counts, got: {combined}"
     );
 }
+
+#[test]
+fn test_normalize_strict_requires_language_for_single_language_formats() {
+    let temp_dir = TempDir::new().unwrap();
+    let input = temp_dir.path().join("Localizable.strings");
+    fs::write(&input, "\"hello\" = \"Hello\";\n").unwrap();
+
+    let output = langcodec_cmd()
+        .args(["--strict", "normalize", "-i", input.to_str().unwrap()])
+        .output()
+        .unwrap();
+
+    assert!(
+        !output.status.success(),
+        "expected strict normalize to fail without language inference"
+    );
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert!(
+        combined.contains("missing language"),
+        "expected strict missing-language error, got: {combined}"
+    );
+}
+
+#[test]
+fn test_normalize_reports_no_matches_for_glob_patterns() {
+    let temp_dir = TempDir::new().unwrap();
+    let missing_glob = temp_dir.path().join("missing").join("*.strings");
+
+    let output = langcodec_cmd()
+        .args(["normalize", "-i", missing_glob.to_str().unwrap()])
+        .output()
+        .unwrap();
+
+    assert!(
+        !output.status.success(),
+        "expected normalize to fail when glob pattern matches no files"
+    );
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert!(
+        combined.contains("No input files matched the provided patterns"),
+        "expected no-match glob error, got: {combined}"
+    );
+}

langcodec/src/normalize.rs

@@ -55,7 +55,7 @@ fn normalize_codec_in_place(
                 let transformed = transform_key_style(&entry.id, options.key_style);
                 if let Some(existing) = seen.get(&transformed) {
                     return Err(Error::validation_error(format!(
-                        "key-style collision in resource '{}' (domain '{}'): '{}' and '{}' both normalize to '{}'",
+                        "key-style collision in language '{}' (domain '{}'): '{}' and '{}' both normalize to '{}'",
                         resource.metadata.language,
                         resource.metadata.domain,
                         existing,
@@ -85,20 +85,14 @@ fn normalize_codec_in_place(
             }
         }
 
-        let before_order: Vec<String> = resource
+        let already_sorted = resource
             .entries
-            .iter()
-            .map(|entry| entry.id.clone())
-            .collect();
-        resource
-            .entries
-            .sort_by(|left, right| left.id.cmp(&right.id));
-        let after_order: Vec<String> = resource
-            .entries
-            .iter()
-            .map(|entry| entry.id.clone())
-            .collect();
-        if before_order != after_order {
+            .windows(2)
+            .all(|pair| pair[0].id <= pair[1].id);
+        if !already_sorted {
+            resource
+                .entries
+                .sort_by(|left, right| left.id.cmp(&right.id));
             changed = true;
         }
     }