fix: share setup that can be shared on all platforms

Author: Bilb

crowdin/generate_android_strings.py

@@ -6,7 +6,7 @@
 import re
 from pathlib import Path
 from colorama import Fore, Style
-from generate_shared import load_glossary_dict, clean_string
+from generate_shared import load_glossary_dict, clean_string, setup_generation
 
 # Variables that should be treated as numeric (using %d)
 NUMERIC_VARIABLES = ['count', 'found_count', 'total_count']
@@ -144,26 +144,9 @@ def convert_non_translatable_strings_to_kotlin(input_file, output_path):
     return app_name
 
 def convert_all_files(input_directory):
-    # Extract the project information
-    print(f"\033[2K{Fore.WHITE}⏳ Processing project info...{Style.RESET_ALL}", end='\r')
-    project_info_file = os.path.join(input_directory, "_project_info.json")
-    if not os.path.exists(project_info_file):
-        raise FileNotFoundError(f"Could not find '{project_info_file}' in raw translations directory")
-
-    project_details = {}
-    with open(project_info_file, 'r', encoding="utf-8") as file:
-        project_details = json.load(file)
-
-    # Extract the language info and sort the target languages alphabetically by locale
-    source_language = project_details['data']['sourceLanguage']
-    target_languages = project_details['data']['targetLanguages']
-    target_languages.sort(key=lambda x: x['locale'])
-    num_languages = len(target_languages)
-    print(f"\033[2K{Fore.GREEN}✅ Project info processed, {num_languages} languages will be converted{Style.RESET_ALL}")
-
-    # Convert the non-translatable strings to the desired format
-    print(f"\033[2K{Fore.WHITE}⏳ Generating static strings file...{Style.RESET_ALL}", end='\r')
-    non_translatable_strings_file = os.path.join(input_directory, "_non_translatable_strings.json")
+    setup_values = setup_generation(input_directory)
+    source_language, rtl_languages, non_translatable_strings_file, target_languages = setup_values.values()
+
     app_name = convert_non_translatable_strings_to_kotlin(non_translatable_strings_file, NON_TRANSLATABLE_STRINGS_OUTPUT_PATH)
     print(f"\033[2K{Fore.GREEN}✅ Static string generation complete{Style.RESET_ALL}")
 

crowdin/generate_desktop_strings.py

@@ -5,7 +5,7 @@
 import argparse
 from pathlib import Path
 from colorama import Fore, Style
-from generate_shared import clean_string, load_glossary_dict
+from generate_shared import clean_string, load_glossary_dict, setup_generation
 
 # Customizable mapping for output folder hierarchy
 # Add entries here to customize the output path for specific locales
@@ -93,7 +93,6 @@ def convert_xliff_to_json(input_file, output_dir, locale, locale_two_letter_code
     sorted_translations = sorted(translations.items())
     converted_translations = {}
 
-
     for resname, target in sorted_translations:
         converted_translations[resname] = generate_icu_pattern(target, glossary_dict)
 
@@ -138,24 +137,8 @@ def convert_non_translatable_strings_to_type_script(input_file, output_path, exp
 
 
 def convert_all_files(input_directory):
-    # Extract the project information
-    print(f"\033[2K{Fore.WHITE}⏳ Processing project info...{Style.RESET_ALL}", end='\r')
-    project_info_file = os.path.join(input_directory, "_project_info.json")
-    if not os.path.exists(project_info_file):
-        raise FileNotFoundError(f"Could not find '{project_info_file}' in raw translations directory")
-
-    project_details = {}
-    with open(project_info_file, 'r', encoding="utf-8") as file:
-        project_details = json.load(file)
-
-    non_translatable_strings_file = os.path.join(input_directory, "_non_translatable_strings.json")
-
-    # Extract the language info and sort the target languages alphabetically by locale
-    source_language = project_details['data']['sourceLanguage']
-    target_languages = project_details['data']['targetLanguages']
-    target_languages.sort(key=lambda x: x['locale'])
-    num_languages = len(target_languages)
-    print(f"\033[2K{Fore.GREEN}✅ Project info processed, {num_languages} languages will be converted{Style.RESET_ALL}")
+    setup_values = setup_generation(input_directory)
+    source_language, rtl_languages, non_translatable_strings_file, target_languages = setup_values.values()
 
     # Convert the XLIFF data to the desired format
     print(f"\033[2K{Fore.WHITE}⏳ Converting translations to target format...{Style.RESET_ALL}", end='\r')
@@ -174,7 +157,6 @@ def convert_all_files(input_directory):
     # Convert the non-translatable strings to the desired format
     print(f"\033[2K{Fore.WHITE}⏳ Generating static strings file...{Style.RESET_ALL}", end='\r')
 
-    rtl_languages = [lang for lang in target_languages if lang["textDirection"] == "rtl"]
     convert_non_translatable_strings_to_type_script(non_translatable_strings_file, NON_TRANSLATABLE_STRINGS_OUTPUT_PATH, exported_locales, rtl_languages)
     print(f"\033[2K{Fore.GREEN}✅ Static string generation complete{Style.RESET_ALL}")
 

crowdin/generate_ios_strings.py

@@ -7,7 +7,7 @@
 from pathlib import Path
 from colorama import Fore, Style
 from datetime import datetime
-from generate_shared import load_glossary_dict, clean_string
+from generate_shared import load_glossary_dict, clean_string, setup_generation
 
 
 # It seems that Xcode uses different language codes and doesn't support all of the languages we get from Crowdin
@@ -109,7 +109,7 @@ def convert_placeholders_for_plurals(translations):
     # Replace {count} with %lld for iOS
     converted_translations = {}
     for form, value in translations.items():
-        converted_translations[form] = clean_string(value.replace('{count}', '%lld'), False, {}, {})
+        converted_translations[form] = clean_string(value, False, {}, {'{count}': '%lld'})
 
     return converted_translations
 
@@ -240,26 +240,10 @@ def convert_non_translatable_strings_to_swift(input_file, output_path):
         file.write('}\n')
 
 def convert_all_files(input_directory):
-    # Extract the project information
-    print(f"\033[2K{Fore.WHITE}⏳ Processing project info...{Style.RESET_ALL}", end='\r')
-    project_info_file = os.path.join(input_directory, "_project_info.json")
-    if not os.path.exists(project_info_file):
-        raise FileNotFoundError(f"Could not find '{project_info_file}' in raw translations directory")
-
-    project_details = {}
-    with open(project_info_file, 'r', encoding="utf-8") as file:
-        project_details = json.load(file)
-
-    # Extract the language info and sort the target languages alphabetically by locale
-    source_language = project_details['data']['sourceLanguage']
-    target_languages = project_details['data']['targetLanguages']
-    target_languages.sort(key=lambda x: x['locale'])
-    num_languages = len(target_languages)
-    print(f"\033[2K{Fore.GREEN}✅ Project info processed, {num_languages} languages will be converted{Style.RESET_ALL}")
-
-    # Convert the non-translatable strings to the desired format
+    setup_values = setup_generation(input_directory)
+    source_language, rtl_languages, non_translatable_strings_file, target_languages = setup_values.values()
     print(f"\033[2K{Fore.WHITE}⏳ Generating static strings file...{Style.RESET_ALL}", end='\r')
-    non_translatable_strings_file = os.path.join(input_directory, "_non_translatable_strings.json")
+
     convert_non_translatable_strings_to_swift(non_translatable_strings_file, NON_TRANSLATABLE_STRINGS_OUTPUT_PATH)
     print(f"\033[2K{Fore.GREEN}✅ Static string generation complete{Style.RESET_ALL}")
 

crowdin/generate_shared.py

@@ -1,10 +1,10 @@
 import html
 import json
 import os
+from colorama import Fore, Style
 
 def clean_string(text, is_android, glossary_dict, extra_replace_dict):
-    to_ret = text
-    if(is_android):
+    if is_android:
         # Note: any changes done for all platforms needs most likely to be done on crowdin side.
         # So we don't want to replace -> with → for instance, we want the crowdin strings to not have those at all.
         # We can use standard XML escaped characters for most things (since XLIFF is an XML format) but
@@ -20,16 +20,16 @@ def clean_string(text, is_android, glossary_dict, extra_replace_dict):
     else:
         text = html.unescape(text)          # Unescape any HTML escaping
 
-    stripped = to_ret.strip()               # Strip whitespace
+    text = text.strip()               # Strip whitespace
 
     # replace all the defined constants (from crowdin's glossary) in the string
     for glossary_key in glossary_dict:
-        stripped = stripped.replace("{" + glossary_key + "}", glossary_dict[glossary_key])
+        text = text.replace("{" + glossary_key + "}", glossary_dict[glossary_key])
 
     # if extra_replace_dict has keys, replace those too
     for extra_key in extra_replace_dict:
-        stripped = stripped.replace(extra_key, extra_replace_dict[extra_key])
-    return stripped
+        text = text.replace(extra_key, extra_replace_dict[extra_key])
+    return text
 
 
 def load_glossary_dict(input_file):
@@ -48,3 +48,32 @@ def load_glossary_dict(input_file):
     }
 
     return glossary_dict
+
+
+def setup_generation(input_directory):
+    # Extract the project information
+    print(f"\033[2K{Fore.WHITE}⏳ Processing project info...{Style.RESET_ALL}", end='\r')
+    project_info_file = os.path.join(input_directory, "_project_info.json")
+    if not os.path.exists(project_info_file):
+        raise FileNotFoundError(f"Could not find '{project_info_file}' in raw translations directory")
+
+    project_details = {}
+    with open(project_info_file, 'r', encoding="utf-8") as file:
+        project_details = json.load(file)
+
+    non_translatable_strings_file = os.path.join(input_directory, "_non_translatable_strings.json")
+
+    # Extract the language info and sort the target languages alphabetically by locale
+    source_language = project_details['data']['sourceLanguage']
+    target_languages = project_details['data']['targetLanguages']
+    target_languages.sort(key=lambda x: x['locale'])
+    num_languages = len(target_languages)
+    print(f"\033[2K{Fore.GREEN}✅ Project info processed, {num_languages} languages will be converted{Style.RESET_ALL}")
+
+    # Convert the non-translatable strings to the desired format
+    rtl_languages = [lang for lang in target_languages if lang["textDirection"] == "rtl"]
+
+    return {"source_language":source_language,
+            "rtl_languages": rtl_languages,
+            "non_translatable_strings_file":non_translatable_strings_file,
+            "target_languages": target_languages}