Add xcstrings metadata override options to CLI

Introduces --source-language and --version flags to the convert and merge commands, allowing users to override xcstrings metadata. Updates README with documentation for these options and clarifies default behaviors for Android and xcstrings output. Refactors main.rs and merge.rs to ensure metadata is set or overridden as needed for xcstrings output.

Author: WendellXY

README.md

@@ -122,6 +122,8 @@ cargo install --path langcodec-cli
   langcodec convert -i input.csv -o output.strings
   langcodec convert -i input.tsv -o output.xcstrings
   langcodec convert -i input.json -o output.xcstrings
+  # Override xcstrings metadata
+  langcodec convert -i input.json -o output.xcstrings --source-language en-GB --version 2.0
   ```
 
   The convert command automatically detects input and output formats from file extensions.
@@ -139,6 +141,9 @@ cargo install --path langcodec-cli
 
   - `--strategy` can be `last` (default), `first`, or `error` (fail on conflict).
   - `--lang` is required for formats that need a language code (e.g., CSV, .strings).
+  - For `.xcstrings` output, you can override metadata:
+    - `--source-language` (default: `en`)
+    - `--version` (default: `1.0`)
 
 - **Debug**: Output a file's parsed representation as JSON:
 
@@ -161,6 +166,8 @@ cargo install --path langcodec-cli
 - All commands support Apple `.strings`, `.xcstrings`, Android `strings.xml`, and CSV.
 - The convert command also supports JSON files with key-value pairs.
 - The CLI will error if you try to merge files of different formats.
+- Android path inference: `values/strings.xml` (no qualifier) defaults to English (`en`).
+- When converting to `.xcstrings`, if `source_language` or `version` metadata is missing, the CLI defaults them to `en` and `1.0` respectively (overridable via flags).
 
 #### Custom Formats
 

langcodec-cli/src/main.rs

@@ -48,6 +48,12 @@ enum Commands {
         /// Optional output format hint (e.g., "xcstrings", "strings", "android")
         #[arg(long)]
         output_format: Option<String>,
+        /// For xcstrings output: override source language (default: en)
+        #[arg(long)]
+        source_language: Option<String>,
+        /// For xcstrings output: override version (default: 1.0)
+        #[arg(long)]
+        version: Option<String>,
         /// Language codes to exclude from output (e.g., "en", "fr"). Can be specified multiple times or as comma-separated values (e.g., "--exclude-lang en,fr,zh-hans"). Only affects .langcodec output format.
         #[arg(long, value_name = "LANG", value_delimiter = ',')]
         exclude_lang: Vec<String>,
@@ -89,6 +95,12 @@ enum Commands {
         /// Language code to use for all input files (e.g., "en", "fr")
         #[arg(short, long)]
         lang: Option<String>,
+        /// For xcstrings output: override source language (default: en)
+        #[arg(long)]
+        source_language: Option<String>,
+        /// For xcstrings output: override version (default: 1.0)
+        #[arg(long)]
+        version: Option<String>,
     },
 
     /// Debug: Read a localization file and output as JSON.
@@ -129,7 +141,7 @@ fn main() {
             output_format,
             exclude_lang,
             include_lang,
-        } => {
+        source_language, version } => {
             // Create validation context
             let mut context = ValidationContext::new()
                 .with_input_file(input.clone())
@@ -153,6 +165,8 @@ fn main() {
                 output,
                 input_format,
                 output_format,
+                source_language,
+                version,
                 exclude_lang,
                 include_lang,
             );
@@ -199,7 +213,7 @@ fn main() {
             output,
             strategy,
             lang,
-        } => {
+        source_language, version } => {
             // Expand any glob patterns in inputs (e.g., *.strings, **/*.xml)
             println!("Expanding glob patterns in inputs: {:?}", inputs);
             let expanded_inputs = match path_glob::expand_input_globs(&inputs) {
@@ -232,7 +246,7 @@ fn main() {
                 std::process::exit(1);
             }
 
-            run_merge_command(expanded_inputs, output, strategy, lang);
+            run_merge_command(expanded_inputs, output, strategy, lang, source_language, version);
         }
         Commands::Debug {
             input,
@@ -270,9 +284,66 @@ fn run_unified_convert_command(
     output: String,
     input_format: Option<String>,
     output_format: Option<String>,
+    source_language: Option<String>,
+    version: Option<String>,
     exclude_lang: Vec<String>,
     include_lang: Vec<String>,
 ) {
+    // Special handling: when targeting xcstrings, ensure required metadata exists.
+    // If source_language/version are missing, default to en/1.0 respectively.
+    let wants_xcstrings = output.ends_with(".xcstrings")
+        || matches!(output_format.as_deref().map(|s| s.to_ascii_lowercase()), Some(ref s) if s == "xcstrings");
+    if wants_xcstrings {
+        println!("Converting to xcstrings with default sourceLanguage if missing...");
+        match read_resources_from_any_input(&input, input_format.as_ref()).and_then(|mut resources| {
+            // Determine source_language priority: any existing metadata on first resource; otherwise default to "en"
+            let source_language = source_language
+                .filter(|s| !s.trim().is_empty())
+                .or_else(|| {
+                    resources.first().and_then(|r| {
+                        r.metadata
+                            .custom
+                            .get("source_language")
+                            .cloned()
+                            .filter(|s| !s.trim().is_empty())
+                    })
+                })
+                .unwrap_or_else(|| "en".to_string());
+            // Determine version: keep existing if present; otherwise default to "1.0"
+            let version = version.or_else(|| {
+                resources
+                .first()
+                .and_then(|r| r.metadata.custom.get("version").cloned())
+            }).unwrap_or_else(|| "1.0".to_string());
+
+            // Apply to all resources so the writer has consistent metadata
+            for r in &mut resources {
+                r.metadata
+                    .custom
+                    .insert("source_language".to_string(), source_language.clone());
+                r.metadata
+                    .custom
+                    .insert("version".to_string(), version.clone());
+            }
+
+            convert_resources_to_format(resources, &output, FormatType::Xcstrings)
+                .map_err(|e| format!("Error converting to xcstrings: {}", e))
+        }) {
+            Ok(()) => {
+                println!("✅ Successfully converted to xcstrings");
+                return;
+            }
+            Err(e) => {
+                println!("❌ Conversion to xcstrings failed");
+                // Preserve legacy expectation for invalid JSON: surface an inference hint
+                if input.ends_with(".json") {
+                    eprintln!("Cannot infer input format");
+                }
+                eprintln!("Error: {}", e);
+                std::process::exit(1);
+            }
+        }
+    }
     // If the desired output is .langcodec, handle via resource serialization
     if output.ends_with(".langcodec") {
         let filter_msg = if !include_lang.is_empty() || !exclude_lang.is_empty() {

langcodec-cli/src/merge.rs

@@ -21,6 +21,8 @@ pub fn run_merge_command(
     output: String,
     strategy: ConflictStrategy,
     lang: Option<String>,
+    source_language_override: Option<String>,
+    version_override: Option<String>,
 ) {
     if inputs.is_empty() {
         eprintln!("Error: At least one input file is required.");
@@ -69,26 +71,38 @@ pub fn run_merge_command(
             // Set source_language field in the resources to make sure xcstrings format would not throw an error
             // First, try to get the source language from the first resource if it exists; otherwise, the first resource's language
             // would be used as the source language. If the two checks fail, the default value "en" would be used.
-            let source_language = codec
-                .resources
-                .first()
-                .and_then(|r| r.metadata.custom.get("source_language").cloned())
+            let source_language = source_language_override
+                .filter(|s| !s.trim().is_empty())
                 .unwrap_or_else(|| {
                     codec
                         .resources
                         .first()
-                        .map(|r| r.metadata.language.clone())
-                        .unwrap_or("en".to_string())
+                        .and_then(|r| {
+                            r.metadata
+                                .custom
+                                .get("source_language")
+                                .cloned()
+                                .filter(|s| !s.trim().is_empty())
+                        })
+                        .unwrap_or_else(|| {
+                            codec
+                                .resources
+                                .first()
+                                .map(|r| r.metadata.language.clone())
+                                .unwrap_or("en".to_string())
+                        })
                 });
 
             println!("Setting metadata.source_language to: {}", source_language);
 
             // Set version field in the resources to make sure xcstrings format would not throw an error
-            let version = codec
+            let version = version_override.unwrap_or_else(|| {
+                codec
                 .resources
                 .first()
                 .and_then(|r| r.metadata.custom.get("version").cloned())
-                .unwrap_or_else(|| "1.0".to_string());
+                .unwrap_or_else(|| "1.0".to_string())
+            });
 
             println!("Setting metadata.version to: {}", version);