flutter-dev 0.1.2__tar.gz → 0.1.4__tar.gz

{flutter_dev-0.1.2 → flutter_dev-0.1.4}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project are documented in this file.
 
+## 0.1.4 - 2026-06-15
+
+### Added
+
+- Added `fdev arb-to-csv` to export Flutter ARB localization files from `lib/l10n` into `translations.csv` by default.
+- Added `fdev csv-to-arb` to generate `app_<locale>.arb` files into `lib/l10n` from `translations.csv` by default.
+- Added Python regression coverage for ARB/CSV conversion, locale parsing, default paths, and ARB metadata preservation.
+
+### Changed
+
+- Documented the ARB/CSV localization workflow in the README command reference and quick-start examples.
+
+## 0.1.3 - 2026-06-08
+
+### Fixed
+
+- Fixed CocoaPods command execution for `fdev pod` and `fdev ipa` so pod subcommands keep their arguments on macOS and Linux.
+
 ## 0.1.2 - 2026-06-07
 
 ### Changed

{flutter_dev-0.1.2 → flutter_dev-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flutter-dev
-Version: 0.1.2
+Version: 0.1.4
 Summary: A cross-platform CLI toolkit for Flutter development workflows.
 Author: Royal Court BD
 License-Expression: MIT
@@ -41,12 +41,13 @@ The package is published on PyPI as `flutter-dev` and installs console commands
 pip install flutter-dev
 ```
 
-Current package metadata declares version `0.1.1`, Python `>=3.8`, MIT license, and support for macOS, Linux, and Windows.
+Current package metadata declares version `0.1.4`, Python `>=3.8`, MIT license, and support for macOS, Linux, and Windows.
 
 ## Key Features
 
 - Flutter build automation for APK, split APK, AAB, IPA, release install, and Firebase web deploy.
 - Project maintenance helpers for `flutter clean`, dependency refresh, `build_runner`, localization generation, analysis, formatting, cache repair, and CocoaPods.
+- Localization CSV helpers for exporting ARB files to translator-friendly CSV files and generating ARB files back from CSV.
 - Android device helpers for APK install, app uninstall, foreground app data clearing, screen mirroring with `scrcpy`, wireless ADB setup, and Date & Time settings.
 - AI-assisted Git commits using Groq, Mistral, SambaNova, or OpenRouter-compatible chat completion APIs.
 - Git workflow helpers for version tags, branch sync, deployment branch merge, discard, and GitHub account management through `gh`.
@@ -129,6 +130,12 @@ fdev doctor
 # Generate localization files
 fdev lang
 
+# Export ARB translations from lib/l10n to translations.csv
+fdev arb-to-csv
+
+# Generate ARB files in lib/l10n from translations.csv
+fdev csv-to-arb
+
 # Run build_runner
 fdev db
 
@@ -167,6 +174,8 @@ Android APK/AAB build commands rename output files using the Android app label a
 | `fdev setup` | Runs clean, dependency upgrade, `build_runner`, localization generation, another dependency upgrade, `flutter analyze`, and `dart format .`. |
 | `fdev cleanup` | Runs clean, pub get, `dart fix --apply`, `dart format .`, and `flutter pub upgrade --major-versions`. |
 | `fdev lang` | Runs `flutter gen-l10n`. |
+| `fdev arb-to-csv` | Exports `lib/l10n/*.arb` into `translations.csv` by default. Use `-d/--directory` and `-o/--output` to override paths. |
+| `fdev csv-to-arb` | Generates `app_<locale>.arb` files into `lib/l10n` from `translations.csv` by default. Use `-i/--input` and `-o/--output-dir` to override paths. |
 | `fdev db` | Runs `dart run build_runner build --delete-conflicting-outputs`. |
 | `fdev cache-repair` | Runs `flutter pub cache repair`. |
 | `fdev pod` | Updates CocoaPods from the `ios/` directory after removing `Podfile.lock` when present. |
@@ -450,6 +459,7 @@ For local packaging checks:
 
 ```bash
 python -m pip install --upgrade build twine
+rm -rf dist build flutter_dev.egg-info
 python -m build
 python -m twine check dist/*
 ```

{flutter_dev-0.1.2 → flutter_dev-0.1.4}/README.md

@@ -8,12 +8,13 @@ The package is published on PyPI as `flutter-dev` and installs console commands
 pip install flutter-dev
 ```
 
-Current package metadata declares version `0.1.1`, Python `>=3.8`, MIT license, and support for macOS, Linux, and Windows.
+Current package metadata declares version `0.1.4`, Python `>=3.8`, MIT license, and support for macOS, Linux, and Windows.
 
 ## Key Features
 
 - Flutter build automation for APK, split APK, AAB, IPA, release install, and Firebase web deploy.
 - Project maintenance helpers for `flutter clean`, dependency refresh, `build_runner`, localization generation, analysis, formatting, cache repair, and CocoaPods.
+- Localization CSV helpers for exporting ARB files to translator-friendly CSV files and generating ARB files back from CSV.
 - Android device helpers for APK install, app uninstall, foreground app data clearing, screen mirroring with `scrcpy`, wireless ADB setup, and Date & Time settings.
 - AI-assisted Git commits using Groq, Mistral, SambaNova, or OpenRouter-compatible chat completion APIs.
 - Git workflow helpers for version tags, branch sync, deployment branch merge, discard, and GitHub account management through `gh`.
@@ -96,6 +97,12 @@ fdev doctor
 # Generate localization files
 fdev lang
 
+# Export ARB translations from lib/l10n to translations.csv
+fdev arb-to-csv
+
+# Generate ARB files in lib/l10n from translations.csv
+fdev csv-to-arb
+
 # Run build_runner
 fdev db
 
@@ -134,6 +141,8 @@ Android APK/AAB build commands rename output files using the Android app label a
 | `fdev setup` | Runs clean, dependency upgrade, `build_runner`, localization generation, another dependency upgrade, `flutter analyze`, and `dart format .`. |
 | `fdev cleanup` | Runs clean, pub get, `dart fix --apply`, `dart format .`, and `flutter pub upgrade --major-versions`. |
 | `fdev lang` | Runs `flutter gen-l10n`. |
+| `fdev arb-to-csv` | Exports `lib/l10n/*.arb` into `translations.csv` by default. Use `-d/--directory` and `-o/--output` to override paths. |
+| `fdev csv-to-arb` | Generates `app_<locale>.arb` files into `lib/l10n` from `translations.csv` by default. Use `-i/--input` and `-o/--output-dir` to override paths. |
 | `fdev db` | Runs `dart run build_runner build --delete-conflicting-outputs`. |
 | `fdev cache-repair` | Runs `flutter pub cache repair`. |
 | `fdev pod` | Updates CocoaPods from the `ios/` directory after removing `Podfile.lock` when present. |
@@ -417,6 +426,7 @@ For local packaging checks:
 
 ```bash
 python -m pip install --upgrade build twine
+rm -rf dist build flutter_dev.egg-info
 python -m build
 python -m twine check dist/*
 ```

{flutter_dev-0.1.2 → flutter_dev-0.1.4}/fdev.py

@@ -47,6 +47,10 @@ from managers.mirror import (
 from managers.merge import (
     merge_files,
 )
+from managers.localization import (
+    arb_to_csv_command,
+    csv_to_arb_command,
+)
 from managers.ai import (
     show_ai_status,
     switch_ai_service,
@@ -86,6 +90,8 @@ def show_usage():
     print("  cleanup      Clean project and get dependencies")
     print("  cache-repair Repair pub cache")
     print("  page         Create page structure (usage: fdev page <page_name>)")
+    print("  arb-to-csv   Export ARB localization files to CSV")
+    print("  csv-to-arb   Generate ARB localization files from CSV")
 
     print(f"\n{BLUE}Device Commands:{NC}")
     print("  install      Install built APK on connected device")
@@ -129,6 +135,8 @@ def show_usage():
     print(f"  {GREEN}fdev git{NC}                       # Interactive GitHub account manager")
     print(f"  {GREEN}fdev git switch royalcourtbd{NC}   # Switch to a specific GH account")
     print(f"  {GREEN}fdev git config{NC}                # Update git user.name / user.email")
+    print(f"  {GREEN}fdev arb-to-csv{NC}                # Export lib/l10n ARB files to translations.csv")
+    print(f"  {GREEN}fdev csv-to-arb{NC}                # Generate lib/l10n ARB files from translations.csv")
 
     print(f"\n{BLUE}Note:{NC}")
     print(f"  {YELLOW}Multiple devices detected?{NC} Tool will prompt you to select one.")
@@ -172,6 +180,10 @@ def main():
         repair_cache()
     elif command == "cleanup":
         cleanup_project()
+    elif command == "arb-to-csv":
+        sys.exit(arb_to_csv_command(sys.argv[2:]))
+    elif command == "csv-to-arb":
+        sys.exit(csv_to_arb_command(sys.argv[2:]))
 
     # Device commands
     elif command == "install":

{flutter_dev-0.1.2 → flutter_dev-0.1.4}/flutter_dev.egg-info/SOURCES.txt

@@ -26,7 +26,9 @@ managers/device.py
 managers/doctor.py
 managers/git.py
 managers/git_account.py
+managers/localization.py
 managers/merge.py
 managers/mirror.py
 managers/project.py
-managers/web_deploy.py
+managers/web_deploy.py
+tests/test_localization.py

{flutter_dev-0.1.2 → flutter_dev-0.1.4}/managers/build.py

@@ -56,7 +56,7 @@ def run_flutter_command(cmd_list, description, env=None):
         env: Optional environment variables dict (default: inherits current env)
     """
     # Windows compatibility for shell commands
-    shell_needed = (is_windows() and cmd_list[0] in ['timeout', 'start', 'flutter', 'dart']) or cmd_list[0] == 'pod'
+    shell_needed = is_windows() and cmd_list[0] in ['timeout', 'start', 'flutter', 'dart']
 
     process = subprocess.Popen(
         cmd_list,

flutter_dev-0.1.4/managers/localization.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""
+Localization Manager - ARB and CSV conversion helpers.
+"""
+
+import argparse
+import csv
+import json
+import os
+import tempfile
+from collections import OrderedDict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from common_utils import BLUE, CHECKMARK, GREEN, RED, YELLOW, NC
+
+
+DEFAULT_ARB_DIRECTORY = Path("lib/l10n")
+DEFAULT_CSV_FILE = Path("translations.csv")
+
+
+@dataclass
+class LocalizationConversionResult:
+    """Summary returned by localization conversion functions."""
+
+    languages: List[str]
+    total_keys: int
+    output_path: Optional[Path] = None
+    output_directory: Optional[Path] = None
+    files_written: int = 0
+    missing_translations: int = 0
+
+
+def extract_language_code(filename):
+    """Extract the locale from an ARB filename."""
+    stem = Path(filename).stem
+    if "_" in stem:
+        return stem.split("_", 1)[1]
+    return stem
+
+
+def _load_arb_messages(filepath):
+    with open(filepath, "r", encoding="utf-8") as file:
+        data = json.load(file, object_pairs_hook=OrderedDict)
+
+    return OrderedDict((key, value) for key, value in data.items() if not key.startswith("@"))
+
+
+def _order_arb_files(arb_files):
+    sorted_files = sorted(arb_files, key=lambda path: path.name)
+    english_files = [path for path in sorted_files if extract_language_code(path.name) == "en"]
+    if not english_files:
+        return sorted_files
+    return english_files + [path for path in sorted_files if path not in english_files]
+
+
+def convert_arb_to_csv(arb_directory=DEFAULT_ARB_DIRECTORY, output_file=DEFAULT_CSV_FILE):
+    """Convert ARB files from a directory into one CSV file."""
+    arb_dir = Path(arb_directory)
+    output_path = Path(output_file)
+
+    if not arb_dir.exists():
+        raise FileNotFoundError(f"ARB directory does not exist: {arb_dir}")
+    if not arb_dir.is_dir():
+        raise NotADirectoryError(f"ARB path is not a directory: {arb_dir}")
+
+    arb_files = _order_arb_files(list(arb_dir.glob("*.arb")))
+    if not arb_files:
+        raise FileNotFoundError(f"No ARB files found in {arb_dir}")
+
+    all_data = OrderedDict()
+    languages = []
+    ordered_keys = []
+    seen_keys = set()
+
+    for arb_file in arb_files:
+        lang_code = extract_language_code(arb_file.name)
+        messages = _load_arb_messages(arb_file)
+
+        all_data[lang_code] = messages
+        languages.append(lang_code)
+
+        for key in messages.keys():
+            if key not in seen_keys:
+                ordered_keys.append(key)
+                seen_keys.add(key)
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    missing_translations = 0
+
+    with open(output_path, "w", newline="", encoding="utf-8") as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerow(["key"] + languages)
+
+        for key in ordered_keys:
+            row = [key]
+            for lang in languages:
+                if key not in all_data[lang]:
+                    missing_translations += 1
+                row.append(all_data[lang].get(key, ""))
+            writer.writerow(row)
+
+    return LocalizationConversionResult(
+        languages=languages,
+        total_keys=len(ordered_keys),
+        output_path=output_path,
+        missing_translations=missing_translations,
+    )
+
+
+def _read_csv_translations(input_file):
+    csv_path = Path(input_file)
+    if not csv_path.exists():
+        raise FileNotFoundError(f"CSV file does not exist: {csv_path}")
+
+    with open(csv_path, "r", encoding="utf-8", newline="") as file:
+        reader = csv.reader(file)
+        try:
+            header = next(reader)
+        except StopIteration:
+            raise ValueError("CSV file is empty")
+
+        if not header or header[0].strip() != "key":
+            raise ValueError("First CSV column must be 'key'")
+
+        languages = [language.strip() for language in header[1:] if language.strip()]
+        if not languages:
+            raise ValueError("CSV must include at least one language column")
+
+        translations = OrderedDict((language, OrderedDict()) for language in languages)
+        keys = []
+        seen_keys = set()
+
+        for row_number, row in enumerate(reader, start=2):
+            if not row or not any(cell.strip() for cell in row):
+                continue
+
+            key = row[0].strip()
+            if not key:
+                raise ValueError(f"Row {row_number}: key is required")
+            if key in seen_keys:
+                raise ValueError(f"Row {row_number}: duplicate key '{key}'")
+
+            keys.append(key)
+            seen_keys.add(key)
+
+            for index, language in enumerate(languages):
+                value = row[index + 1] if index + 1 < len(row) else ""
+                translations[language][key] = value
+
+    return languages, keys, translations
+
+
+def _load_existing_metadata(arb_file):
+    if not arb_file.exists():
+        return OrderedDict(), OrderedDict()
+
+    with open(arb_file, "r", encoding="utf-8") as file:
+        data = json.load(file, object_pairs_hook=OrderedDict)
+
+    global_metadata = OrderedDict()
+    message_metadata = OrderedDict()
+
+    for key, value in data.items():
+        if key == "@@locale":
+            continue
+        if key.startswith("@@"):
+            global_metadata[key] = value
+        elif key.startswith("@"):
+            message_metadata[key] = value
+
+    return global_metadata, message_metadata
+
+
+def _atomic_write_json(file_path, data):
+    temp_name = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            "w",
+            delete=False,
+            dir=str(file_path.parent),
+            encoding="utf-8",
+        ) as temp_file:
+            json.dump(data, temp_file, ensure_ascii=False, indent=2)
+            temp_file.write("\n")
+            temp_name = temp_file.name
+
+        os.replace(temp_name, file_path)
+    finally:
+        if temp_name and os.path.exists(temp_name):
+            os.unlink(temp_name)
+
+
+def convert_csv_to_arb(input_file=DEFAULT_CSV_FILE, output_directory=DEFAULT_ARB_DIRECTORY):
+    """Convert one CSV translation file into ARB files."""
+    output_dir = Path(output_directory)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    languages, keys, translations = _read_csv_translations(input_file)
+
+    for language in languages:
+        arb_file = output_dir / f"app_{language}.arb"
+        global_metadata, message_metadata = _load_existing_metadata(arb_file)
+
+        arb_data = OrderedDict()
+        arb_data["@@locale"] = language
+        for key, value in global_metadata.items():
+            arb_data[key] = value
+
+        for key in keys:
+            arb_data[key] = translations[language][key]
+            metadata_key = f"@{key}"
+            if metadata_key in message_metadata:
+                arb_data[metadata_key] = message_metadata[metadata_key]
+
+        _atomic_write_json(arb_file, arb_data)
+
+    return LocalizationConversionResult(
+        languages=languages,
+        total_keys=len(keys),
+        output_directory=output_dir,
+        files_written=len(languages),
+    )
+
+
+def arb_to_csv_command(argv=None):
+    """CLI entry point for ARB to CSV export."""
+    parser = argparse.ArgumentParser(
+        prog="fdev arb-to-csv",
+        description="Export Flutter ARB localization files to a CSV file.",
+    )
+    parser.add_argument(
+        "-d",
+        "--directory",
+        default=str(DEFAULT_ARB_DIRECTORY),
+        help="Directory containing ARB files (default: lib/l10n)",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        default=str(DEFAULT_CSV_FILE),
+        help="Output CSV file path (default: translations.csv)",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        result = convert_arb_to_csv(args.directory, args.output)
+    except (OSError, ValueError, json.JSONDecodeError) as error:
+        print(f"{RED}Error: {error}{NC}")
+        return 1
+
+    print(f"{CHECKMARK} ARB files exported to CSV.")
+    print(f"{BLUE}Output:{NC} {result.output_path}")
+    print(f"{BLUE}Languages:{NC} {', '.join(result.languages)}")
+    print(f"{BLUE}Total keys:{NC} {result.total_keys}")
+    if result.missing_translations:
+        print(f"{YELLOW}Missing translations:{NC} {result.missing_translations}")
+    return 0
+
+
+def csv_to_arb_command(argv=None):
+    """CLI entry point for CSV to ARB generation."""
+    parser = argparse.ArgumentParser(
+        prog="fdev csv-to-arb",
+        description="Generate Flutter ARB localization files from a CSV file.",
+    )
+    parser.add_argument(
+        "-i",
+        "--input",
+        default=str(DEFAULT_CSV_FILE),
+        help="Input CSV file path (default: translations.csv)",
+    )
+    parser.add_argument(
+        "-o",
+        "--output-dir",
+        default=str(DEFAULT_ARB_DIRECTORY),
+        help="Directory where ARB files will be written (default: lib/l10n)",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        result = convert_csv_to_arb(args.input, args.output_dir)
+    except (OSError, ValueError, json.JSONDecodeError) as error:
+        print(f"{RED}Error: {error}{NC}")
+        return 1
+
+    print(f"{CHECKMARK} CSV translations generated ARB files.")
+    print(f"{BLUE}Output directory:{NC} {result.output_directory}")
+    print(f"{BLUE}Languages:{NC} {', '.join(result.languages)}")
+    print(f"{BLUE}Total keys:{NC} {result.total_keys}")
+    print(f"{GREEN}Files written:{NC} {result.files_written}")
+    return 0

{flutter_dev-0.1.2 → flutter_dev-0.1.4}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=69", "wheel"]
+requires = ["setuptools>=77.0.3", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "flutter-dev"
-version = "0.1.2"
+version = "0.1.4"
 description = "A cross-platform CLI toolkit for Flutter development workflows."
 readme = "README.md"
 requires-python = ">=3.8"

flutter_dev-0.1.4/tests/test_localization.py

@@ -0,0 +1,93 @@
+import csv
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from managers.localization import (
+    convert_arb_to_csv,
+    convert_csv_to_arb,
+    extract_language_code,
+)
+
+
+class LocalizationConversionTests(unittest.TestCase):
+    def test_extract_language_code_preserves_multi_part_locale(self):
+        self.assertEqual(extract_language_code("app_en.arb"), "en")
+        self.assertEqual(extract_language_code("app_pt_BR.arb"), "pt_BR")
+
+    def test_convert_arb_to_csv_uses_default_l10n_folder_and_en_first(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            l10n = root / "lib" / "l10n"
+            l10n.mkdir(parents=True)
+            (l10n / "app_bn.arb").write_text(
+                json.dumps(
+                    {
+                        "@@locale": "bn",
+                        "hello": "হ্যালো",
+                        "onlyBn": "শুধু বাংলা",
+                    },
+                    ensure_ascii=False,
+                ),
+                encoding="utf-8",
+            )
+            (l10n / "app_en.arb").write_text(
+                json.dumps(
+                    {
+                        "@@locale": "en",
+                        "hello": "Hello",
+                        "onlyEn": "Only English",
+                    },
+                    ensure_ascii=False,
+                ),
+                encoding="utf-8",
+            )
+
+            result = convert_arb_to_csv(root / "lib" / "l10n", root / "translations.csv")
+
+            self.assertEqual(result.total_keys, 3)
+            self.assertEqual(result.languages, ["en", "bn"])
+            with (root / "translations.csv").open(encoding="utf-8", newline="") as file:
+                rows = list(csv.reader(file))
+            self.assertEqual(rows[0], ["key", "en", "bn"])
+            self.assertIn(["hello", "Hello", "হ্যালো"], rows)
+            self.assertIn(["onlyEn", "Only English", ""], rows)
+            self.assertIn(["onlyBn", "", "শুধু বাংলা"], rows)
+
+    def test_convert_csv_to_arb_writes_default_l10n_folder_and_preserves_metadata(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            l10n = root / "lib" / "l10n"
+            l10n.mkdir(parents=True)
+            (l10n / "app_en.arb").write_text(
+                json.dumps(
+                    {
+                        "@@locale": "en",
+                        "hello": "Old",
+                        "@hello": {"description": "Greeting text"},
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                ),
+                encoding="utf-8",
+            )
+            (root / "translations.csv").write_text(
+                "key,en,bn\nhello,Hello,হ্যালো\nbye,Bye,বিদায়\n",
+                encoding="utf-8",
+            )
+
+            result = convert_csv_to_arb(root / "translations.csv", root / "lib" / "l10n")
+
+            self.assertEqual(result.languages, ["en", "bn"])
+            en_data = json.loads((l10n / "app_en.arb").read_text(encoding="utf-8"))
+            bn_data = json.loads((l10n / "app_bn.arb").read_text(encoding="utf-8"))
+            self.assertEqual(en_data["@@locale"], "en")
+            self.assertEqual(en_data["hello"], "Hello")
+            self.assertEqual(en_data["@hello"], {"description": "Greeting text"})
+            self.assertEqual(bn_data["@@locale"], "bn")
+            self.assertEqual(bn_data["bye"], "বিদায়")
+
+
+if __name__ == "__main__":
+    unittest.main()