Fixed apple-plurals parsing and regeneration.

Author: strump

python_twine/tests/fixtures/formatter_apple_plurals.stringsdict

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+
+<!-- ********** Strings for downloading map from search **********/ -->
+
+	<key>bookmarks_places</key>
+	<dict>
+		<key>NSStringLocalizedFormatKey</key>
+		<string>%#@value@</string>
+		<key>value</key>
+		<dict>
+			<key>NSStringFormatSpecTypeKey</key>
+			<string>NSStringPluralRuleType</string>
+			<key>NSStringFormatValueTypeKey</key>
+			<string>d</string>
+			<key>one</key>
+			<string>%d bookmark</string>
+			<key>other</key>
+			<string>%d bookmarks</string>
+		</dict>
+	</dict>
+
+	<key>tracks</key>
+	<dict>
+		<key>NSStringLocalizedFormatKey</key>
+		<string>%#@value@</string>
+		<key>value</key>
+		<dict>
+			<key>NSStringFormatSpecTypeKey</key>
+			<string>NSStringPluralRuleType</string>
+			<key>NSStringFormatValueTypeKey</key>
+			<string>d</string>
+			<key>one</key>
+			<string>%d track</string>
+			<key>other</key>
+			<string>%d tracks</string>
+		</dict>
+	</dict>
+
+</dict>
+</plist>

python_twine/tests/test_formatters_plural.py

@@ -165,14 +165,19 @@ def test_read_plurals(self, fixtures_dir):
 
 class TestApplePluralFormatter:
     @pytest.fixture
-    def formatter(self):
+    def formatter(self) -> ApplePluralFormatter:
         """Create formatter with empty TwineFile."""
         formatter = ApplePluralFormatter()
         formatter.options = {"consume_all": True, "consume_comments": True}
         return formatter
 
     @pytest.fixture
-    def twine_file(self):
+    def fixtures_dir(self) -> Path:
+        """Get fixtures directory path."""
+        return Path(__file__).parent / "fixtures"
+
+    @pytest.fixture
+    def twine_file(self) -> TwineFile:
         # Prepare TwineFile data
         twine_file = TwineFile()
         num_edits_def = TwineDefinition("num_edits")
@@ -198,6 +203,23 @@ def twine_file(self):
 
         return twine_file
 
+    def test_read_stringsdict(self, formatter:ApplePluralFormatter, fixtures_dir):
+        """Test reading Android XML format with <plural/> tags."""
+        fixture_path = fixtures_dir / "formatter_apple_plurals.stringsdict"
+        with open(fixture_path, "r", encoding="utf-8") as f:
+            formatter.read(f, "en")
+
+        twine_file = formatter.twine_file
+
+        assert "bookmarks_places" in twine_file.definitions_by_key
+        translations1 = twine_file.definitions_by_key["bookmarks_places"].plural_translations
+        assert translations1 == {"en": {"one": "%d bookmark", "other": "%d bookmarks"}}
+
+        assert "tracks" in twine_file.definitions_by_key
+        translations2 = twine_file.definitions_by_key["tracks"].plural_translations
+        assert translations2 == {"en": {"one": "%d track", "other": "%d tracks"}}
+
+
     def test_write_plural_format(self, formatter, twine_file):
         formatter.twine_file = twine_file
 

python_twine/twine/formatters/__init__.py

@@ -18,6 +18,16 @@ def flatten(input: List[List[str]]) -> List[str]:
         flat += group
     return flat
 
+def find_dict_diff(dict1: dict, dict2: dict):
+    keys = dict1.keys() | dict2.keys()
+    for key in sorted(keys):
+        if key in dict1 and key not in dict2:
+            yield key, dict1[key], None
+        elif key not in dict1 and key in dict2:
+            yield key, None, dict2[key]
+        elif dict1[key] != dict2[key]:
+            yield key, dict1[key], dict2[key]
+
 class AbstractFormatter(ABC):
     """Base class for all format formatters."""
 
@@ -105,8 +115,7 @@ def set_translation_for_key(self, key: str, lang: str, value: str, section_name:
 
     def set_translation_for_key_plural(self, key: str, lang: str, values: Dict[str, str], section_name:Optional[str]):
         """ Set plular values translation for a key in a specific language.
-            This method is similar to set_translation_for_key(). Let's keep both
-            methods for simplicity.
+            This method is similar to set_translation_for_key() but with dict values.
         """
         # Normalize newlines
         values = {key:val.replace("\n", "\\n") for (key, val) in values.items()}
@@ -123,10 +132,14 @@ def set_translation_for_key_plural(self, key: str, lang: str, values: Dict[str,
             # Only set if no reference or value differs from reference
             if not reference or values != reference.plural_translations.get(lang):
                 if lang in definition.plural_translations and definition.plural_translations[lang] != values:
-                    msg = (f"Translation '{values}' overrides existing translation '{definition.plural_translations[lang]}' "
-                           f"for key '{key}' and lang '{lang}' (comment '{definition.comment}').")
-                    self.add_validation_error(msg)
-                definition.plural_translations[lang] = values
+                    for quantity, value_old, value_new in find_dict_diff(definition.plural_translations[lang], values):
+                        msg = (f"Translation '{value_new}' overrides existing translation '{value_old}' "
+                                   f"for key '{key}:{quantity}' and lang '{lang}'")
+                        self.add_validation_error(msg)
+                if lang in definition.plural_translations:
+                    definition.plural_translations[lang].update(values)
+                else:
+                    definition.plural_translations[lang] = values
             if "tags" in self.options:
                 definition.add_tags(flatten(self.options["tags"]))
 

python_twine/twine/formatters/apple_plural.py

@@ -4,6 +4,7 @@
 
 from typing import Dict, Optional, TextIO
 from xml.etree import ElementTree as ET
+from xml.etree.ElementTree import Element
 
 from twine.formatters.apple import AppleFormatter
 from twine.placeholders import convert_placeholders_from_android_to_twine
@@ -128,94 +129,27 @@ def read(self, io: TextIO, lang: str):
             comment_text = None
             for j in range(i - 1, -1, -1):
                 prev = children[j]
-                if isinstance(prev, ET.Comment):
+                # Handle comments (they have a callable tag function)
+                if callable(prev.tag):
                     comment_text = prev.text.strip() if prev.text else None
                     break
                 elif prev.tag is not None:  # Hit another element
                     break
 
             # Extract plural hash
-            plural_hash = {}
-
-            # Find <key>value</key><dict> inside value_container
-            value_dict = None
-            value_children = list(value_container)
-
-            for j, inner_key in enumerate(value_children):
-                if inner_key.tag == "key" and inner_key.text == "value":
-                    if j + 1 < len(value_children):
-                        value_dict = value_children[j + 1]
-                        break
-
-            if value_dict is not None and value_dict.tag == "dict":
-                # Extract plural entries
-                plural_children = list(value_dict)
-                j = 0
-
-                while j < len(plural_children):
-                    pkey_elem = plural_children[j]
-
-                    if pkey_elem.tag == "key":
-                        pkey = pkey_elem.text
-
-                        if pkey in TwineDefinition.PLURAL_KEYS:
-                            if j + 1 < len(plural_children):
-                                string_elem = plural_children[j + 1]
-
-                                if string_elem.tag == "string":
-                                    pvalue = string_elem.text or ""
-                                    plural_hash[pkey] = pvalue
-
-                    j += 1
+            plural_hash = self.extract_plural_dict(value_container)
 
             if not plural_hash:
                 i += 2
                 continue
 
             # Get or create definition
-            definition = self.twine_file.definitions_by_key.get(key_name)
-
-            if not definition:
-                if self.options.get("consume_all"):
-                    print(
-                        f"Adding new plural definition '{key_name}' to twine file.",
-                        file=twine.stdout,
-                    )
-
-                    # Find or create Uncategorized section
-                    current_section = next(
-                        (
-                            s
-                            for s in self.twine_file.sections
-                            if s.name == "Uncategorized"
-                        ),
-                        None,
-                    )
-
-                    if not current_section:
-                        current_section = TwineSection("Uncategorized")
-                        self.twine_file.sections.insert(0, current_section)
-
-                    definition = TwineDefinition(key_name)
-                    current_section.definitions.append(definition)
-                    self.twine_file.definitions_by_key[key_name] = definition
-                else:
-                    print(
-                        f"WARNING: '{key_name}' not found in twine file (plural).",
-                        file=twine.stdout,
-                    )
-                    i += 2
-                    continue
-
-            # Merge plural translations
-            if lang not in definition.plural_translations:
-                definition.plural_translations[lang] = {}
-
-            definition.plural_translations[lang].update(plural_hash)
-
-            # Set base translation to 'other' if present
-            if "other" in plural_hash:
-                self.set_translation_for_key(key_name, lang, plural_hash["other"])
+            if not self.match_default_lang_translation(key_name, lang, plural_hash):
+                self.set_translation_for_key_plural(key_name, lang, plural_hash, section_name=None)
+
+                # Set base translation to 'other' if present
+                if "other" in plural_hash:
+                    self.set_translation_for_key(key_name, lang, plural_hash["other"], section_name=None)
 
             # Set comment if requested
             if comment_text and self.options.get("consume_comments"):
@@ -227,9 +161,75 @@ def read(self, io: TextIO, lang: str):
 
             i += 2
 
+    def extract_plural_dict(self, value_element: Element) -> dict:
+        """ Parse next XML structure to extract key-value pairs:
+        	<dict>
+                <key>NSStringLocalizedFormatKey</key>
+                <string>%#@value@</string>
+                <key>value</key>
+                <dict>
+                    <key>NSStringFormatSpecTypeKey</key>
+                    <string>NSStringPluralRuleType</string>
+                    <key>NSStringFormatValueTypeKey</key>
+                    <string>d</string>
+                    <key>one</key>
+                    <string>%d bookmark</string>
+                    <key>other</key>
+                    <string>%d bookmarks</string>
+                </dict>
+            </dict>
+        """
+        plural_dict = {}
+
+        # Find <key>value</key><dict> inside value_element
+        value_dict = None
+        value_children = list(value_element)
+
+        for j, inner_key in enumerate(value_children):
+            if inner_key.tag == "key" and inner_key.text == "value":
+                if j + 1 < len(value_children):
+                    value_dict = value_children[j + 1]
+                    break
+
+        if value_dict is not None and value_dict.tag == "dict":
+            # Extract plural entries
+            plural_children = list(value_dict)
+            j = 0
+
+            while j < len(plural_children):
+                pkey_elem = plural_children[j]
+
+                if pkey_elem.tag == "key":
+                    pkey = pkey_elem.text
+
+                    if pkey in TwineDefinition.PLURAL_KEYS:
+                        if j + 1 < len(plural_children):
+                            string_elem = plural_children[j + 1]
+
+                            if string_elem.tag == "string":
+                                pvalue = string_elem.text or ""
+                                plural_dict[pkey] = pvalue
+
+                j += 1
+        return plural_dict
+
     def should_include_definition(self, definition, lang: str) -> bool:
         """Only include plural definitions."""
         return (
             definition.is_plural()
             and definition.plural_translation_for_lang(lang) is not None
         )
+
+    def match_default_lang_translation(self, key:str, lang:str, value:dict) -> bool:
+        """ Apple strings file for non-default language (es, de, fr, etc) contains
+            default value for not translated keys. That's why in Slovenian .strings
+            file you can find english words.
+            If `value` matches translation from default language, it means that
+            this string is not translated.
+        """
+        default_lang = self.twine_file.get_developer_language_code()
+        if default_lang is None:
+            return False
+        if default_lang == lang:
+            return False
+        return self.twine_file.definitions_by_key[key].plural_translations[default_lang] == value

python_twine/twine/output_processor.py

@@ -78,6 +78,7 @@ def process(self, language: str) -> TwineFile:
         """
         result = TwineFile()
         result.language_codes = self.twine_file.language_codes.copy()
+        fallbacks = self.fallback_languages(language)
 
         for section in self.twine_file.sections:
             new_section = TwineSection(section.name)
@@ -99,7 +100,6 @@ def process(self, language: str) -> TwineFile:
 
                 # Try fallback languages if no translation found
                 if value is None and include_option != "translated":
-                    fallbacks = self.fallback_languages(language)
                     value = definition.translation_for_lang(fallbacks)
 
                 # Skip if still no value
@@ -112,8 +112,10 @@ def process(self, language: str) -> TwineFile:
 
                 # Handle plural translations
                 if definition.is_plural():
-                    if language not in new_definition.plural_translations:
-                        new_definition.plural_translations[language] = {}
+                    if language not in new_definition.plural_translations \
+                            and include_option != "translated":
+                        lng = definition.find_plural_lang_fallback(fallbacks)
+                        new_definition.plural_translations[language] = definition.plural_translation_for_lang(lng)
 
                     # Ensure 'other' key exists for plurals
                     if "other" not in new_definition.plural_translations[language]:

python_twine/twine/twine_file.py

@@ -122,6 +122,13 @@ def translation_for_lang(self, lang: str | List[str]) -> Optional[str]:
 
         return None
 
+    def find_plural_lang_fallback(self, fallback_langs: List[str]) -> Optional[str]:
+        """ Find first language from `fallback_langs` which is in plural_translations. """
+        return next(
+            filter(lambda lng: lng in self.plural_translations,
+                   fallback_langs),
+            None)
+
     def plural_translation_for_lang(self, lang: str) -> Optional[Dict[str, str]]:
         """
         Get plural translations for a language, sorted by PLURAL_KEYS order.