133 lines
4.9 KiB
Python
Executable File
133 lines
4.9 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Read-only drift check for shared i18n key coverage.
|
|
|
|
Compares `shared/i18n/key-manifest.json` against `shared/i18n/lobby.json` and
|
|
fails fast when keyspaces drift between frontend/backend contract sections.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from pathlib import Path
|
|
import sys
|
|
from typing import Any
|
|
|
|
|
|
REPO_ROOT = Path(__file__).resolve().parents[1]
|
|
CATALOG_PATH = REPO_ROOT / "shared" / "i18n" / "lobby.json"
|
|
MANIFEST_PATH = REPO_ROOT / "shared" / "i18n" / "key-manifest.json"
|
|
|
|
|
|
def _load_json(path: Path) -> dict[str, Any]:
|
|
with path.open("r", encoding="utf-8") as handle:
|
|
return json.load(handle)
|
|
|
|
|
|
def _as_set(value: Any) -> set[str]:
|
|
if not isinstance(value, list):
|
|
return set()
|
|
return {str(item) for item in value}
|
|
|
|
|
|
def _require_translations(
|
|
errors: dict[str, Any],
|
|
locales: set[str],
|
|
label: str,
|
|
failures: list[str],
|
|
) -> None:
|
|
for key, translations in errors.items():
|
|
if not isinstance(translations, dict):
|
|
failures.append(f"{label}.{key} must be an object of locale->message")
|
|
continue
|
|
|
|
for locale in sorted(locales):
|
|
value = translations.get(locale)
|
|
if not isinstance(value, str) or not value.strip():
|
|
failures.append(f"{label}.{key} missing non-empty '{locale}' translation")
|
|
|
|
|
|
def main() -> int:
|
|
catalog = _load_json(CATALOG_PATH)
|
|
manifest = _load_json(MANIFEST_PATH)
|
|
|
|
failures: list[str] = []
|
|
|
|
manifest_locales = _as_set(manifest.get("locales"))
|
|
catalog_locales = _as_set(catalog.get("locales", {}).get("supported"))
|
|
if manifest_locales != catalog_locales:
|
|
failures.append(
|
|
"locale set mismatch: "
|
|
f"manifest={sorted(manifest_locales)} catalog={sorted(catalog_locales)}"
|
|
)
|
|
|
|
frontend_manifest = _as_set(manifest.get("frontend_error_keys"))
|
|
frontend_catalog = set(catalog.get("frontend", {}).get("errors", {}).keys())
|
|
if frontend_manifest != frontend_catalog:
|
|
failures.append(
|
|
"frontend error key mismatch: "
|
|
f"manifest-only={sorted(frontend_manifest - frontend_catalog)} "
|
|
f"catalog-only={sorted(frontend_catalog - frontend_manifest)}"
|
|
)
|
|
|
|
backend_code_manifest = _as_set(manifest.get("backend_error_codes"))
|
|
backend_code_catalog = set(catalog.get("backend", {}).get("error_codes", {}).keys())
|
|
if backend_code_manifest != backend_code_catalog:
|
|
failures.append(
|
|
"backend error code mismatch: "
|
|
f"manifest-only={sorted(backend_code_manifest - backend_code_catalog)} "
|
|
f"catalog-only={sorted(backend_code_catalog - backend_code_manifest)}"
|
|
)
|
|
|
|
backend_key_manifest = _as_set(manifest.get("backend_error_keys"))
|
|
backend_key_catalog = set(catalog.get("backend", {}).get("errors", {}).keys())
|
|
if backend_key_manifest != backend_key_catalog:
|
|
failures.append(
|
|
"backend error key mismatch: "
|
|
f"manifest-only={sorted(backend_key_manifest - backend_key_catalog)} "
|
|
f"catalog-only={sorted(backend_key_catalog - backend_key_manifest)}"
|
|
)
|
|
|
|
backend_to_frontend = catalog.get("contract", {}).get("backend_to_frontend_error_keys", {})
|
|
if not isinstance(backend_to_frontend, dict):
|
|
failures.append("contract.backend_to_frontend_error_keys must be an object")
|
|
backend_to_frontend = {}
|
|
|
|
for code in sorted(backend_code_catalog):
|
|
frontend_key = backend_to_frontend.get(code)
|
|
if frontend_key is None:
|
|
failures.append(f"missing contract mapping for backend code '{code}'")
|
|
continue
|
|
if frontend_key not in frontend_catalog:
|
|
failures.append(
|
|
f"mapping for backend code '{code}' points to unknown frontend key '{frontend_key}'"
|
|
)
|
|
|
|
allowed_contract_only_codes = _as_set(manifest.get("allowed_contract_only_backend_codes"))
|
|
unknown_mapping_codes = set(backend_to_frontend.keys()) - backend_code_catalog
|
|
disallowed_unknown_mapping_codes = unknown_mapping_codes - allowed_contract_only_codes
|
|
if disallowed_unknown_mapping_codes:
|
|
failures.append(
|
|
"contract contains mappings for unknown backend codes: "
|
|
f"{sorted(disallowed_unknown_mapping_codes)}"
|
|
)
|
|
|
|
_require_translations(catalog.get("frontend", {}).get("errors", {}), manifest_locales, "frontend.errors", failures)
|
|
_require_translations(catalog.get("backend", {}).get("errors", {}), manifest_locales, "backend.errors", failures)
|
|
|
|
if failures:
|
|
print("i18n drift check FAILED")
|
|
for failure in failures:
|
|
print(f" - {failure}")
|
|
return 1
|
|
|
|
print("i18n drift check OK")
|
|
print(f" - locales: {sorted(manifest_locales)}")
|
|
print(f" - frontend error keys: {len(frontend_catalog)}")
|
|
print(f" - backend error codes: {len(backend_code_catalog)}")
|
|
print(f" - backend error keys: {len(backend_key_catalog)}")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|