feat(types): introduce Empty translation variant for better handling of untranslated entries

WendellXY · WendellXY · commit b8c6988310a5 · 2025-10-05T16:28:10.000+08:00
- Added a new `Empty` variant to the `Translation` enum to represent empty translation entries.
- Updated various parts of the codebase to handle this new variant, ensuring that empty translations are appropriately managed across different formats and functions.
- This change improves the handling of untranslated items, allowing for clearer representation and processing of localization resources.
diff --git a/langcodec-cli/src/debug.rs b/langcodec-cli/src/debug.rs
@@ -44,6 +44,7 @@ pub fn run_debug_command(input: String, lang: Option<String>, output: Option<Str
     for resource in &mut codec.resources {
         for entry in &mut resource.entries {
             entry.value = match &entry.value {
+                Translation::Empty => Translation::Empty,
                 Translation::Singular(v) => Translation::Singular(v.replace("\\n", "\n")),
                 Translation::Plural(p) => Translation::Plural(Plural {
                     id: p.id.clone(),
diff --git a/langcodec-cli/src/edit.rs b/langcodec-cli/src/edit.rs
@@ -290,6 +290,7 @@ fn apply_set_to_file(
             let old = codec
                 .find_entry(key, lang_ref)
                 .map(|e| match &e.value {
+                    Translation::Empty => String::new(),
                     Translation::Singular(s) => s.clone(),
                     Translation::Plural(p) => p.id.clone(),
                 })
diff --git a/langcodec-cli/src/view.rs b/langcodec-cli/src/view.rs
@@ -67,6 +67,9 @@ pub fn print_view(codec: &Codec, lang_filter: &Option<String>, full: bool) {
             }
 
             match &entry.value {
+                langcodec::types::Translation::Empty => {
+                    println!("    Type: Empty");
+                }
                 langcodec::types::Translation::Singular(value) => {
                     println!("    Type: Singular");
                     if full {
diff --git a/langcodec-cli/tests/langcodec_output_simple_tests.rs b/langcodec-cli/tests/langcodec_output_simple_tests.rs
@@ -182,6 +182,7 @@ fn test_langcodec_output_structure() {
             assert!(!entry.id.is_empty(), "Entry should have id");
             // Value should be either Singular or Plural
             match &entry.value {
+                langcodec::Translation::Empty => {}
                 langcodec::Translation::Singular(s) => {
                     assert!(!s.is_empty(), "Singular value should not be empty")
                 }
diff --git a/langcodec/src/codec.rs b/langcodec/src/codec.rs
@@ -699,6 +699,7 @@ impl Codec {
         for res in &self.resources {
             for entry in &res.entries {
                 let sigs: Vec<Vec<String>> = match &entry.value {
+                    Translation::Empty => vec![],
                     Translation::Singular(v) => vec![signature(v)],
                     Translation::Plural(p) => p.forms.values().map(|v| signature(v)).collect(),
                 };
@@ -766,6 +767,7 @@ impl Codec {
         for res in &self.resources {
             for entry in &res.entries {
                 let sigs: Vec<Vec<String>> = match &entry.value {
+                    Translation::Empty => vec![],
                     Translation::Singular(v) => vec![signature(v)],
                     Translation::Plural(p) => p.forms.values().map(|v| signature(v)).collect(),
                 };
@@ -826,6 +828,9 @@ impl Codec {
         for res in &mut self.resources {
             for entry in &mut res.entries {
                 match &mut entry.value {
+                    Translation::Empty => {
+                        continue;
+                    }
                     Translation::Singular(v) => {
                         let nv = normalize_placeholders(v);
                         *v = nv;
diff --git a/langcodec/src/converter.rs b/langcodec/src/converter.rs
@@ -260,6 +260,9 @@ pub fn convert_with_normalization<P: AsRef<Path>>(
         for res in &mut resources {
             for entry in &mut res.entries {
                 match &mut entry.value {
+                    crate::types::Translation::Empty => {
+                        continue;
+                    }
                     crate::types::Translation::Singular(v) => {
                         *v = normalize_placeholders(v);
                     }
diff --git a/langcodec/src/formats/android_strings.rs b/langcodec/src/formats/android_strings.rs
@@ -135,6 +135,7 @@ impl From<Resource> for Format {
         let mut plurals = Vec::new();
         for entry in value.entries {
             match entry.value {
+                Translation::Empty => {} // Do nothing
                 Translation::Singular(_) => strings.push(StringResource::from_entry(&entry)),
                 Translation::Plural(p) => {
                     let mut items: Vec<PluralItem> = p
@@ -250,6 +251,7 @@ impl StringResource {
         StringResource {
             name: entry.id.clone(),
             value: match &entry.value {
+                Translation::Empty => String::new(),
                 Translation::Singular(v) => v.clone(),
                 Translation::Plural(_) => String::new(), // Plurals not supported in strings.xml
             },
@@ -469,7 +471,10 @@ World
         assert_eq!(entry.comment, None);
 
         let entry = resource.find_entry("multiple_lines").unwrap();
-        assert_eq!(entry.value, Translation::Singular("Hello\\n\\n\\nWorld\\n    ".to_string()));
+        assert_eq!(
+            entry.value,
+            Translation::Singular("Hello\\n\\n\\nWorld\\n    ".to_string())
+        );
         assert_eq!(entry.status, EntryStatus::Translated);
         assert_eq!(entry.comment, None);
 
diff --git a/langcodec/src/formats/csv.rs b/langcodec/src/formats/csv.rs
@@ -208,6 +208,7 @@ impl TryFrom<Vec<Resource>> for Format {
             for resource in &resources {
                 if let Some(entry) = resource.entries.iter().find(|e| e.id == record.key) {
                     let value = match &entry.value {
+                        Translation::Empty => String::new(),
                         Translation::Singular(v) => v.clone(),
                         Translation::Plural(_) => String::new(), // Plurals not supported
                     };
diff --git a/langcodec/src/formats/strings.rs b/langcodec/src/formats/strings.rs
@@ -502,6 +502,11 @@ impl TryFrom<Entry> for Pair {
     fn try_from(entry: Entry) -> Result<Self, Self::Error> {
         // Strings format only supports singular translations. Preserve the value verbatim.
         match entry.value {
+            Translation::Empty => Ok(Pair {
+                key: entry.id,
+                value: String::new(),
+                comment: entry.comment,
+            }),
             Translation::Singular(value) => Ok(Pair {
                 key: entry.id,
                 value: crate::placeholder::to_ios_placeholders(&value),
diff --git a/langcodec/src/formats/tsv.rs b/langcodec/src/formats/tsv.rs
@@ -211,6 +211,7 @@ impl TryFrom<Vec<Resource>> for Format {
             for resource in &resources {
                 if let Some(entry) = resource.entries.iter().find(|e| e.id == record.key) {
                     let value = match &entry.value {
+                        Translation::Empty => String::new(),
                         Translation::Singular(v) => v.clone(),
                         Translation::Plural(_) => String::new(), // Plurals not supported
                     };
diff --git a/langcodec/src/formats/xcstrings.rs b/langcodec/src/formats/xcstrings.rs
@@ -210,6 +210,7 @@ impl Item {
         let should_translate = Some(entry.status != EntryStatus::DoNotTranslate);
 
         match entry.value {
+            Translation::Empty => {} // Do nothing
             Translation::Singular(value) => {
                 localizations.insert(
                     language,
diff --git a/langcodec/src/types.rs b/langcodec/src/types.rs
@@ -228,6 +228,9 @@ impl Display for Entry {
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum Translation {
+    /// The translation is empty.
+    Empty,
+
     /// A single translation without plural forms.
     Singular(String),
 
@@ -238,6 +241,7 @@ pub enum Translation {
 impl Translation {
     pub fn plain_translation(translation: Translation) -> Translation {
         match translation {
+            Translation::Empty => Translation::Empty,
             Translation::Singular(value) => {
                 Translation::Singular(make_plain_translation_string(value))
             }
@@ -259,6 +263,7 @@ impl Translation {
 
     pub fn plain_translation_string(&self) -> String {
         match self {
+            Translation::Empty => String::new(),
             Translation::Singular(value) => make_plain_translation_string(value.clone()),
             Translation::Plural(plural) => {
                 // Return the plural ID, not the first form
@@ -271,6 +276,7 @@ impl Translation {
 impl Display for Translation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Translation::Empty => write!(f, "Empty"),
             Translation::Singular(value) => write!(f, "{}", value),
             Translation::Plural(plural) => write!(f, "{}", plural.id), // Displaying only the ID for brevity
         }

Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,9 @@ pub fn print_view(codec: &Codec, lang_filter: &Option<String>, full: bool) {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`match &entry.value {`
	`70`	`+ langcodec::types::Translation::Empty => {`
	`71`	`+ println!(" Type: Empty");`
	`72`	`+ }`
`70`	`73`	`langcodec::types::Translation::Singular(value) => {`
`71`	`74`	`println!(" Type: Singular");`
`72`	`75`	`if full {`
Original file line number	Diff line number	Diff line change
`@@ -182,6 +182,7 @@ fn test_langcodec_output_structure() {`
`182`	`182`	`assert!(!entry.id.is_empty(), "Entry should have id");`
`183`	`183`	`// Value should be either Singular or Plural`
`184`	`184`	`match &entry.value {`
	`185`	`+ langcodec::Translation::Empty => {}`
`185`	`186`	`langcodec::Translation::Singular(s) => {`
`186`	`187`	`assert!(!s.is_empty(), "Singular value should not be empty")`
`187`	`188`	`}`