feat(lib): add non-fatal plural validation reports and collection APIs

- Add PluralValidationReport with missing/have sets
- Add collect_resource_plural_issues and Codec::collect_plural_issues
- Refactor validate_plurals to fold reports into an Error

- Replace match-based rules with lazy_static BTreeMap keyed by base language
- Remove region/script variants unreachable with base-language selection
- Keep conservative default to {Other}

- Add PluralValidationReport with missing/have sets
- Add collect_resource_plural_issues and Codec::collect_plural_issues
- Refactor validate_plurals to fold reports into an Error

- Per-language counts of entries with missing plural categories
- Total missing plural categories per language

Author: WendellXY

langcodec/src/codec.rs

@@ -619,20 +619,41 @@ impl Codec {
     /// categories for the language are present. Returns a Validation error with
     /// aggregated details if any are missing.
     pub fn validate_plurals(&self) -> Result<(), Error> {
-        use crate::plural_rules::validate_resource_plurals;
+        use crate::plural_rules::collect_resource_plural_issues;
 
-        let mut problems: Vec<String> = Vec::new();
+        let mut reports = Vec::new();
         for res in &self.resources {
-            if let Err(e) = validate_resource_plurals(res) {
-                problems.push(e.to_string());
-            }
+            reports.extend(collect_resource_plural_issues(res));
         }
 
-        if problems.is_empty() {
-            Ok(())
-        } else {
-            Err(Error::validation_error(problems.join("\n")))
+        if reports.is_empty() {
+            return Ok(());
+        }
+
+        // Fold into an Error message for the validating API
+        let mut lines = Vec::new();
+        for r in reports {
+            let miss: Vec<String> = r.missing.iter().map(|k| format!("{:?}", k)).collect();
+            let have: Vec<String> = r.have.iter().map(|k| format!("{:?}", k)).collect();
+            lines.push(format!(
+                "lang='{}' key='{}': missing plural categories: [{}] (have: [{}])",
+                r.language,
+                r.key,
+                miss.join(", "),
+                have.join(", ")
+            ));
+        }
+        Err(Error::validation_error(lines.join("\n")))
+    }
+
+    /// Collects non-fatal plural validation reports across all resources.
+    pub fn collect_plural_issues(&self) -> Vec<crate::plural_rules::PluralValidationReport> {
+        use crate::plural_rules::collect_resource_plural_issues;
+        let mut reports = Vec::new();
+        for res in &self.resources {
+            reports.extend(collect_resource_plural_issues(res));
         }
+        reports
     }
 
     /// Cleans up resources by removing empty resources and entries.

langcodec/src/lib.rs

@@ -159,7 +159,10 @@ pub use crate::{
     error::Error,
     formats::FormatType,
     placeholder::{extract_placeholders, normalize_placeholders, signature},
-    plural_rules::{required_categories_for_str, validate_resource_plurals},
+    plural_rules::{
+        collect_resource_plural_issues, required_categories_for_str, validate_resource_plurals,
+        PluralValidationReport,
+    },
     types::{
         ConflictStrategy, Entry, EntryStatus, Metadata, Plural, PluralCategory, Resource,
         Translation,

langcodec/src/plural_rules.rs

@@ -7,6 +7,7 @@ use crate::{
     types::{Plural, PluralCategory, Resource, Translation},
 };
 
+use serde::Serialize;
 use lazy_static::lazy_static;
 
 lazy_static! {
@@ -74,6 +75,15 @@ lazy_static! {
     };
 }
 
+/// Non-fatal report describing missing plural categories for a key in a locale.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct PluralValidationReport {
+    pub language: String,
+    pub key: String,
+    pub missing: BTreeSet<PluralCategory>,
+    pub have: BTreeSet<PluralCategory>,
+}
+
 /// Returns the required CLDR plural categories for a given language identifier.
 ///
 /// This is a curated subset of CLDR rules covering common locales. For unknown
@@ -109,49 +119,57 @@ pub fn missing_categories_for_plural(
     &required - &have
 }
 
-/// Validate a single resource for missing plural categories.
-pub fn validate_resource_plurals(resource: &Resource) -> Result<(), Error> {
-    let lang_id = match resource.parse_language_identifier() {
-        Some(id) => id,
-        None => {
-            return Err(Error::validation_error(format!(
-                "Invalid or missing language for resource: {}",
-                resource.metadata.language
-            )));
-        }
+/// Collect non-fatal plural issues for a single resource.
+pub fn collect_resource_plural_issues(resource: &Resource) -> Vec<PluralValidationReport> {
+    let Some(lang_id) = resource.parse_language_identifier() else {
+        return vec![PluralValidationReport {
+            language: resource.metadata.language.clone(),
+            key: String::from("<resource>"),
+            missing: [PluralCategory::Other].into_iter().collect(),
+            have: BTreeSet::new(),
+        }];
     };
 
-    let mut problems: Vec<String> = Vec::new();
-
+    let mut reports = Vec::new();
     for entry in &resource.entries {
         if let Translation::Plural(plural) = &entry.value {
+            let have: BTreeSet<PluralCategory> = plural.forms.keys().cloned().collect();
             let missing = missing_categories_for_plural(&lang_id, plural);
             if !missing.is_empty() {
-                let have: Vec<String> = plural
-                    .forms
-                    .keys()
-                    .map(|k| format!("{:?}", k))
-                    .collect();
-                let miss: Vec<String> = missing.into_iter().map(|k| format!("{:?}", k)).collect();
-                problems.push(format!(
-                    "lang='{}' key='{}': missing plural categories: [{}] (have: [{}])",
-                    resource.metadata.language,
-                    entry.id,
-                    miss.join(", "),
-                    have.join(", ")
-                ));
+                reports.push(PluralValidationReport {
+                    language: resource.metadata.language.clone(),
+                    key: entry.id.clone(),
+                    missing,
+                    have,
+                });
             }
         }
     }
+    reports
+}
 
-    if problems.is_empty() {
-        Ok(())
-    } else {
-        Err(Error::validation_error(format!(
-            "Plural validation failed:\n{}",
-            problems.join("\n")
-        )))
+/// Validate a single resource for missing plural categories.
+pub fn validate_resource_plurals(resource: &Resource) -> Result<(), Error> {
+    let reports = collect_resource_plural_issues(resource);
+    if reports.is_empty() {
+        return Ok(());
+    }
+    let mut lines = Vec::new();
+    for r in reports {
+        let miss: Vec<String> = r.missing.iter().map(|k| format!("{:?}", k)).collect();
+        let have: Vec<String> = r.have.iter().map(|k| format!("{:?}", k)).collect();
+        lines.push(format!(
+            "lang='{}' key='{}': missing plural categories: [{}] (have: [{}])",
+            r.language,
+            r.key,
+            miss.join(", "),
+            have.join(", ")
+        ));
     }
+    Err(Error::validation_error(format!(
+        "Plural validation failed:\n{}",
+        lines.join("\n")
+    )))
 }
 
 #[cfg(test)]
@@ -207,4 +225,35 @@ mod tests {
         let err = validate_resource_plurals(&resource).unwrap_err();
         assert!(format!("{}", err).contains("missing plural categories"));
     }
+
+    #[test]
+    fn test_collect_resource_plural_issues() {
+        // English requires one/other; missing 'one' should yield a report
+        let resource = Resource {
+            metadata: Metadata {
+                language: "en".into(),
+                domain: String::new(),
+                custom: Default::default(),
+            },
+            entries: vec![Entry {
+                id: "apples".into(),
+                value: Translation::Plural(Plural::new(
+                    "apples",
+                    vec![(PluralCategory::Other, "%d apples".to_string())].into_iter(),
+                )
+                .unwrap()),
+                comment: None,
+                status: EntryStatus::Translated,
+                custom: Default::default(),
+            }],
+        };
+
+        let reports = collect_resource_plural_issues(&resource);
+        assert_eq!(reports.len(), 1);
+        let r = &reports[0];
+        assert_eq!(r.language, "en");
+        assert_eq!(r.key, "apples");
+        assert!(r.missing.contains(&PluralCategory::One));
+        assert!(r.have.contains(&PluralCategory::Other));
+    }
 }