fix(cli): stabilize view json summary and keys schema

Author: WendellXY

langcodec-cli/src/view.rs

@@ -86,33 +86,26 @@ fn plural_category_label(category: &PluralCategory) -> &'static str {
 
 fn render_json_output(
     filtered_resources: &[(&langcodec::Resource, Vec<&langcodec::types::Entry>)],
-    lang_filter: &Option<String>,
     keys_only: bool,
 ) -> Result<String, String> {
     let mut total_matches = 0usize;
     let mut languages = BTreeSet::new();
     let mut status_counts: BTreeMap<String, usize> = BTreeMap::new();
     let mut entries_payload = Vec::new();
-    let mut keys_by_language: BTreeMap<String, Vec<String>> = BTreeMap::new();
-    let mut keys_for_lang = Vec::new();
+    let mut keys_payload = Vec::new();
 
     for (resource, entries) in filtered_resources {
-        languages.insert(resource.metadata.language.clone());
-
         for entry in entries {
+            languages.insert(resource.metadata.language.clone());
             total_matches += 1;
             let status = status_label(&entry.status).to_string();
             *status_counts.entry(status.clone()).or_insert(0) += 1;
 
             if keys_only {
-                if lang_filter.is_some() {
-                    keys_for_lang.push(entry.id.clone());
-                } else {
-                    keys_by_language
-                        .entry(resource.metadata.language.clone())
-                        .or_default()
-                        .push(entry.id.clone());
-                }
+                keys_payload.push(json!({
+                    "lang": resource.metadata.language,
+                    "key": entry.id,
+                }));
                 continue;
             }
 
@@ -156,17 +149,10 @@ fn render_json_output(
     });
 
     let payload = if keys_only {
-        if lang_filter.is_some() {
-            json!({
-                "summary": summary,
-                "keys": keys_for_lang,
-            })
-        } else {
-            json!({
-                "summary": summary,
-                "keys": keys_by_language,
-            })
-        }
+        json!({
+            "summary": summary,
+            "keys": keys_payload,
+        })
     } else {
         json!({
             "summary": summary,
@@ -247,7 +233,7 @@ pub fn print_view(codec: &Codec, lang_filter: &Option<String>, opts: &ViewOption
         .collect::<Vec<_>>();
 
     if opts.json {
-        let rendered = match render_json_output(&filtered_resources, lang_filter, opts.keys_only) {
+        let rendered = match render_json_output(&filtered_resources, opts.keys_only) {
             Ok(text) => text,
             Err(err) => {
                 eprintln!("❌ {}", err);

langcodec-cli/tests/view_status_cli_tests.rs

@@ -82,6 +82,34 @@ fn write_xcstrings_multilang_fixture(path: &std::path::Path) {
     fs::write(path, xcstrings).unwrap();
 }
 
+fn write_xcstrings_partial_match_fixture(path: &std::path::Path) {
+    let xcstrings = r#"{
+  "sourceLanguage": "en",
+  "version": "1.0",
+  "strings": {
+    "needs_review_key": {
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "needs_review",
+            "value": "Needs review EN"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Besoin de revision FR"
+          }
+        }
+      }
+    }
+  }
+}
+"#;
+
+    fs::write(path, xcstrings).unwrap();
+}
+
 #[test]
 fn test_view_status_filters_single_status_for_lang() {
     let temp_dir = TempDir::new().unwrap();
@@ -431,11 +459,84 @@ fn test_view_status_json_keys_only_outputs_keys_payload() {
     assert_eq!(payload["summary"]["statuses"]["needs_review"], 2);
     assert!(payload.get("entries").is_none(), "Expected keys-only payload");
 
-    let keys = payload["keys"].as_object().unwrap();
-    let en_keys = keys["en"].as_array().unwrap();
-    let fr_keys = keys["fr"].as_array().unwrap();
-    assert_eq!(en_keys.len(), 1);
-    assert_eq!(fr_keys.len(), 1);
-    assert_eq!(en_keys[0], "needs_review_key");
-    assert_eq!(fr_keys[0], "needs_review_key");
+    let keys = payload["keys"].as_array().unwrap();
+    assert_eq!(keys.len(), 2);
+    assert!(
+        keys.iter()
+            .any(|item| item["lang"] == "en" && item["key"] == "needs_review_key")
+    );
+    assert!(
+        keys.iter()
+            .any(|item| item["lang"] == "fr" && item["key"] == "needs_review_key")
+    );
+}
+
+#[test]
+fn test_view_status_json_excludes_zero_match_languages_in_summary() {
+    let temp_dir = TempDir::new().unwrap();
+    let input_file = temp_dir.path().join("Localizable.xcstrings");
+    write_xcstrings_partial_match_fixture(&input_file);
+
+    let output = langcodec_cmd()
+        .args([
+            "view",
+            "-i",
+            input_file.to_str().unwrap(),
+            "--status",
+            "needs_review",
+            "--json",
+        ])
+        .output()
+        .unwrap();
+
+    assert!(
+        output.status.success(),
+        "CLI failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let payload: serde_json::Value = serde_json::from_str(&stdout)
+        .unwrap_or_else(|e| panic!("Expected JSON output. parse error: {e}. stdout: {stdout}"));
+
+    let languages = payload["summary"]["languages"].as_array().unwrap();
+    assert_eq!(languages.len(), 1);
+    assert_eq!(languages[0], "en");
+}
+
+#[test]
+fn test_view_status_json_keys_only_lang_uses_consistent_object_schema() {
+    let temp_dir = TempDir::new().unwrap();
+    let input_file = temp_dir.path().join("Localizable.xcstrings");
+    write_xcstrings_multilang_fixture(&input_file);
+
+    let output = langcodec_cmd()
+        .args([
+            "view",
+            "-i",
+            input_file.to_str().unwrap(),
+            "--lang",
+            "en",
+            "--status",
+            "needs_review",
+            "--keys-only",
+            "--json",
+        ])
+        .output()
+        .unwrap();
+
+    assert!(
+        output.status.success(),
+        "CLI failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let payload: serde_json::Value = serde_json::from_str(&stdout)
+        .unwrap_or_else(|e| panic!("Expected JSON output. parse error: {e}. stdout: {stdout}"));
+
+    let keys = payload["keys"].as_array().unwrap();
+    assert!(!keys.is_empty(), "Expected at least one key object");
+    assert!(keys.iter().all(|item| item["lang"] == "en"));
+    assert!(keys.iter().all(|item| item["key"] == "needs_review_key"));
 }