fix(core): preserve xcstrings languages and parse single-lang csv/tsv headers

WendellXY · WendellXY · commit 787484c8de3c · 2026-03-03T19:38:49.000+08:00
diff --git a/langcodec-cli/tests/edit_cli_tests.rs b/langcodec-cli/tests/edit_cli_tests.rs
@@ -368,3 +368,86 @@ fn test_edit_set_continue_on_error() {
     let updated = fs::read_to_string(&good).unwrap();
     assert!(updated.contains("\"welcome\""));
 }
+
+#[test]
+fn test_edit_set_xcstrings_with_lang_preserves_other_languages() {
+    let temp_dir = TempDir::new().unwrap();
+    let input_file = temp_dir.path().join("Localizable.xcstrings");
+    let initial = r#"{
+  "sourceLanguage": "en",
+  "version": "1.0",
+  "strings": {
+    "hello": {
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Hello"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Bonjour"
+          }
+        }
+      }
+    },
+    "bye": {
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Bye"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Au revoir"
+          }
+        }
+      }
+    }
+  }
+}
+"#;
+    fs::write(&input_file, initial).unwrap();
+
+    let out = langcodec_cmd()
+        .args([
+            "edit",
+            "set",
+            "-i",
+            input_file.to_str().unwrap(),
+            "--lang",
+            "en",
+            "-k",
+            "hello",
+            "-v",
+            "Hello Updated",
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        out.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+
+    let content = fs::read_to_string(&input_file).unwrap();
+    let payload: serde_json::Value = serde_json::from_str(&content).unwrap();
+
+    assert_eq!(
+        payload["strings"]["hello"]["localizations"]["en"]["stringUnit"]["value"],
+        "Hello Updated"
+    );
+    assert_eq!(
+        payload["strings"]["hello"]["localizations"]["fr"]["stringUnit"]["value"],
+        "Bonjour"
+    );
+    assert_eq!(
+        payload["strings"]["bye"]["localizations"]["fr"]["stringUnit"]["value"],
+        "Au revoir"
+    );
+}
diff --git a/langcodec/src/codec.rs b/langcodec/src/codec.rs
@@ -1081,7 +1081,7 @@ impl Codec {
         };
 
         for new_resource in &mut new_resources {
-            if let Some(ref lang) = language {
+            if requires_language && let Some(ref lang) = language {
                 new_resource.metadata.language = lang.clone();
             }
             new_resource.metadata.domain = domain.clone();
diff --git a/langcodec/src/formats/csv.rs b/langcodec/src/formats/csv.rs
@@ -95,24 +95,42 @@ impl Parser for Format {
             let first_line = first_line.map_err(Error::CsvParse)?;
 
             if first_line.len() == 2 {
-                // Single language format: key, value
-                // First line is data, not header
-                records.push(MultiLanguageCSVRecord {
-                    key: first_line[0].to_string(),
-                    translations: {
-                        let mut map = HashMap::new();
-                        map.insert("default".to_string(), first_line[1].to_string());
-                        map
-                    },
-                });
-
-                // Process remaining lines
-                for line in lines {
-                    let line = line.map_err(Error::CsvParse)?;
-                    if line.len() == 2 {
-                        let mut record = MultiLanguageCSVRecord::new(line[0].to_string());
-                        record.add_translation("default".to_string(), line[1].to_string());
-                        records.push(record);
+                if first_line[0].trim().eq_ignore_ascii_case("key") {
+                    // Single-language header form: key, <lang>
+                    let language = first_line[1].trim().to_string();
+                    if language.is_empty() {
+                        return Err(Error::DataMismatch(
+                            "Invalid CSV format: missing language in header".to_string(),
+                        ));
+                    }
+                    for line in lines {
+                        let line = line.map_err(Error::CsvParse)?;
+                        if line.len() == 2 {
+                            let mut record = MultiLanguageCSVRecord::new(line[0].to_string());
+                            record.add_translation(language.clone(), line[1].to_string());
+                            records.push(record);
+                        }
+                    }
+                } else {
+                    // Single language data form: key, value
+                    // First line is data, not header
+                    records.push(MultiLanguageCSVRecord {
+                        key: first_line[0].to_string(),
+                        translations: {
+                            let mut map = HashMap::new();
+                            map.insert("default".to_string(), first_line[1].to_string());
+                            map
+                        },
+                    });
+
+                    // Process remaining lines
+                    for line in lines {
+                        let line = line.map_err(Error::CsvParse)?;
+                        if line.len() == 2 {
+                            let mut record = MultiLanguageCSVRecord::new(line[0].to_string());
+                            record.add_translation("default".to_string(), line[1].to_string());
+                            records.push(record);
+                        }
                     }
                 }
             } else if first_line.len() >= 3 {
@@ -400,6 +418,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_parse_single_language_header_csv() {
+        let csv_content = "key,en\nhello,Hello\nbye,Goodbye\n";
+        let format = Format::from_reader(Cursor::new(csv_content)).unwrap();
+        assert_eq!(format.records.len(), 2);
+        assert_eq!(
+            format.records[0].get_translation("en"),
+            Some(&"Hello".to_string())
+        );
+        assert_eq!(
+            format.records[1].get_translation("en"),
+            Some(&"Goodbye".to_string())
+        );
+
+        let resources = Vec::<Resource>::try_from(format).unwrap();
+        assert_eq!(resources.len(), 1);
+        assert_eq!(resources[0].metadata.language, "en");
+    }
+
     #[test]
     fn test_multi_language_csv_to_resources() {
         let csv_content = "key,en,cn\nhello,Hello,你好\nbye,Goodbye,再见\n";
diff --git a/langcodec/src/formats/tsv.rs b/langcodec/src/formats/tsv.rs
@@ -96,24 +96,42 @@ impl Parser for Format {
             let first_line = first_line.map_err(Error::CsvParse)?;
 
             if first_line.len() == 2 {
-                // Single language format: key, value
-                // First line is data, not header
-                records.push(MultiLanguageTSVRecord {
-                    key: first_line[0].to_string(),
-                    translations: {
-                        let mut map = HashMap::new();
-                        map.insert("default".to_string(), first_line[1].to_string());
-                        map
-                    },
-                });
-
-                // Process remaining lines
-                for line in lines {
-                    let line = line.map_err(Error::CsvParse)?;
-                    if line.len() == 2 {
-                        let mut record = MultiLanguageTSVRecord::new(line[0].to_string());
-                        record.add_translation("default".to_string(), line[1].to_string());
-                        records.push(record);
+                if first_line[0].trim().eq_ignore_ascii_case("key") {
+                    // Single-language header form: key, <lang>
+                    let language = first_line[1].trim().to_string();
+                    if language.is_empty() {
+                        return Err(Error::DataMismatch(
+                            "Invalid TSV format: missing language in header".to_string(),
+                        ));
+                    }
+                    for line in lines {
+                        let line = line.map_err(Error::CsvParse)?;
+                        if line.len() == 2 {
+                            let mut record = MultiLanguageTSVRecord::new(line[0].to_string());
+                            record.add_translation(language.clone(), line[1].to_string());
+                            records.push(record);
+                        }
+                    }
+                } else {
+                    // Single language data form: key, value
+                    // First line is data, not header
+                    records.push(MultiLanguageTSVRecord {
+                        key: first_line[0].to_string(),
+                        translations: {
+                            let mut map = HashMap::new();
+                            map.insert("default".to_string(), first_line[1].to_string());
+                            map
+                        },
+                    });
+
+                    // Process remaining lines
+                    for line in lines {
+                        let line = line.map_err(Error::CsvParse)?;
+                        if line.len() == 2 {
+                            let mut record = MultiLanguageTSVRecord::new(line[0].to_string());
+                            record.add_translation("default".to_string(), line[1].to_string());
+                            records.push(record);
+                        }
                     }
                 }
             } else if first_line.len() >= 3 {
@@ -428,6 +446,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_parse_single_language_header_tsv() {
+        let tsv_content = "key\ten\nhello\tHello\nbye\tGoodbye\n";
+        let format = Format::from_reader(Cursor::new(tsv_content)).unwrap();
+        assert_eq!(format.records.len(), 2);
+        assert_eq!(
+            format.records[0].get_translation("en"),
+            Some(&"Hello".to_string())
+        );
+        assert_eq!(
+            format.records[1].get_translation("en"),
+            Some(&"Goodbye".to_string())
+        );
+
+        let resources = Vec::<Resource>::try_from(format).unwrap();
+        assert_eq!(resources.len(), 1);
+        assert_eq!(resources[0].metadata.language, "en");
+    }
+
     #[test]
     fn test_multi_language_tsv_to_resources() {
         let tsv_content = "key\ten\tcn\nhello\tHello\t你好\nbye\tGoodbye\t再见\n";
diff --git a/langcodec/src/read_options.rs b/langcodec/src/read_options.rs
@@ -3,7 +3,7 @@
 /// Read behavior options for [`crate::Codec`] file-loading APIs.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct ReadOptions {
-    /// Optional language hint applied to all loaded resources.
+    /// Optional language hint used for single-language formats (e.g. `.strings`, `strings.xml`).
     pub language_hint: Option<String>,
     /// Enables stricter checks (e.g., language is required for single-language formats).
     pub strict: bool,
diff --git a/langcodec/tests/corpus_regression_tests.rs b/langcodec/tests/corpus_regression_tests.rs
@@ -83,16 +83,6 @@ fn expected_fr_stable_values() -> Vec<ExpectedValue> {
     ]
 }
 
-fn with_language(
-    expected_values: Vec<ExpectedValue>,
-    language: &'static str,
-) -> Vec<ExpectedValue> {
-    expected_values
-        .into_iter()
-        .map(|item| ExpectedValue { language, ..item })
-        .collect()
-}
-
 fn read_codec(path: &Path, lang_hint: Option<&str>) -> Codec {
     let mut codec = Codec::new();
     codec
@@ -199,7 +189,7 @@ fn convert_edge_case_corpora_table_driven() {
     let root = corpus_root();
     let output_dir = tempfile::tempdir().expect("create temp output dir");
 
-    let csv_default_expected = with_language(expected_en_stable_values(), "default");
+    let csv_single_lang_expected = expected_en_stable_values();
 
     let convert_cases = vec![
         ConvertCase {
@@ -221,14 +211,14 @@ fn convert_edge_case_corpora_table_driven() {
             input_relative_path: "en.lproj/Localizable.strings",
             output_file_name: "from_strings.csv",
             output_lang_hint: None,
-            expected_values: csv_default_expected.clone(),
+            expected_values: csv_single_lang_expected.clone(),
         },
         ConvertCase {
             name: "strings -> tsv",
             input_relative_path: "en.lproj/Localizable.strings",
             output_file_name: "from_strings.tsv",
             output_lang_hint: None,
-            expected_values: csv_default_expected,
+            expected_values: csv_single_lang_expected,
         },
         ConvertCase {
             name: "android -> strings",

Original file line number	Diff line number	Diff line change
`@@ -1081,7 +1081,7 @@ impl Codec {`
`1081`	`1081`	`};`
`1082`	`1082`
`1083`	`1083`	`for new_resource in &mut new_resources {`
`1084`		`- if let Some(ref lang) = language {`
	`1084`	`+ if requires_language && let Some(ref lang) = language {`
`1085`	`1085`	`new_resource.metadata.language = lang.clone();`
`1086`	`1086`	`}`
`1087`	`1087`	`new_resource.metadata.domain = domain.clone();`