fix: General fixing and clean-up on translate()

src/viur/core/bones/select.py

@@ -46,6 +46,7 @@ def __init__(
         ] = None,
         values: dict | list | tuple | t.Callable | enum.EnumMeta = (),
         translation_key_prefix: str | t.Callable[[t.Self], str] = "",
+        add_missing_translations: bool = False,
         **kwargs
     ):
         """
@@ -61,6 +62,7 @@ def __init__(
         """
         super().__init__(defaultValue=defaultValue, **kwargs)
         self.translation_key_prefix = translation_key_prefix
+        self.add_missing_translations = add_missing_translations
 
         # handle list/tuple as dicts
         if isinstance(values, (list, tuple)):
@@ -98,8 +100,10 @@ def __getattribute__(self, item):
 
             values = {
                 key: label if isinstance(label, translate) else translate(
-                    f"{prefix}{label}", str(label),
-                    f"value {key} for {self.name}<{type(self).__name__}> in {self.skel_cls.__name__} in {self.skel_cls}"
+                    f"{prefix}{key}", str(label),
+                    f"value {key} for {self.name}<{type(self).__name__}> "
+                    + f"in {self.skel_cls.__name__} in {self.skel_cls}",
+                    add_missing=self.add_missing_translations,
                 )
                 for key, label in values.items()
             }

src/viur/core/config.py

@@ -606,13 +606,17 @@ def available_dialects(self) -> list[str]:
         res |= self.language_alias_map
         return list(res.keys())
 
-    add_missing_translations: bool = False
-    """Add missing translation into datastore.
+    add_missing_translations: bool | str | t.Iterable[str] = False
+    """Add missing translation into datastore, optionally with given fnmatch-patterns.
 
     If a key is not found in the translation table when a translation is
     rendered, a database entry is created with the key and hint and
     default value (if set) so that the translations
     can be entered in the administration.
+
+    Instead of setting add_missing_translations to a boolean, it can also be set to
+    a pattern or iterable of fnmatch-patterns; Only translation keys matching these
+    patterns will be automatically added.
     """
 
 

src/viur/core/i18n.py

@@ -74,6 +74,7 @@
 on your own. Just use the TranslateSkel).
 """  # FIXME: grammar, rst syntax
 import datetime
+import fnmatch
 import logging
 import sys
 import traceback
@@ -161,6 +162,8 @@ class translate:
         "public",
         "filename",
         "lineno",
+        "add_missing",
+        "default_variables",
     )
 
     def __init__(
@@ -170,6 +173,8 @@ def __init__(
         hint: str = None,
         force_lang: str = None,
         public: bool = False,
+        add_missing: bool = False,
+        default_variables: dict[str, t.Any] | None = None,
         caller_is_jinja: bool = False,
     ):
         """
@@ -183,6 +188,7 @@ def __init__(
             target language.
         :param force_lang: Use this language instead the one of the request.
         :param public: Flag for public translations, which can be obtained via /json/_translate/get_public.
+        :param default_variables: Default values for variable substitution.
         :param caller_is_jinja: Is the call caused by our jinja method?
         """
         super().__init__()
@@ -200,6 +206,8 @@ def __init__(
         self.translationCache = None
         self.force_lang = force_lang
         self.public = public
+        self.add_missing = add_missing
+        self.default_variables = default_variables or {}
         self.filename, self.lineno = None, None
 
         if self.key not in systemTranslations and conf.i18n.add_missing_translations:
@@ -227,38 +235,56 @@ def __str__(self) -> str:
         if self.translationCache is None:
             global systemTranslations
 
-            if self.key not in systemTranslations and conf.i18n.add_missing_translations:
-                # This translation seems to be new and should be added
-
-                add_missing_translation(
-                    key=self.key,
-                    hint=self.hint,
-                    default_text=self.defaultText,
-                    filename=self.filename,
-                    lineno=self.lineno,
-                    public=self.public,
-                )
+            if self.key not in systemTranslations:
+                # either the translate()-object has add_missing set
+                if not (add_missing := self.add_missing):
+                    # otherwise, use configuration flag
+                    add_missing = conf.i18n.add_missing_translations
+
+                    # match against fnmatch pattern, when given
+                    if isinstance(add_missing, str):
+                        add_missing = fnmatch.fnmatch(self.key, add_missing)
+                    elif isinstance(add_missing, t.Iterable):
+                        add_missing = any(fnmatch.fnmatch(self.key, pat) for pat in add_missing)
+                    else:
+                        add_missing = bool(add_missing)
+
+                if add_missing:
+                    # This translation seems to be new and should be added
+                    add_missing_translation(
+                        key=self.key,
+                        hint=self.hint,
+                        default_text=self.defaultText,
+                        filename=self.filename,
+                        lineno=self.lineno,
+                        public=self.public,
+                    )
 
             self.translationCache = self.merge_alias(systemTranslations.get(self.key, {}))
 
         if (lang := self.force_lang) is None:
             # The default case: use the request language
             lang = current.language.get()
+
         if value := self.translationCache.get(lang):
-            return value
+            return self.substitute_vars(value, **self.default_variables)
+
         # Use the default text from datastore or from the caller arguments
-        return self.translationCache.get("_default_text_") or self.defaultText
+        return self.substitute_vars(
+            self.translationCache.get("_default_text_") or self.defaultText,
+            **self.default_variables
+        )
 
     def translate(self, **kwargs) -> str:
         """Substitute the given kwargs in the translated or default text."""
-        return self.substitute_vars(str(self), **kwargs)
+        return self.substitute_vars(str(self), **(self.default_variables | kwargs))
 
-    def __call__(self, **kwargs):
+    def __call__(self, **kwargs) -> str:
         """Just an alias for translate"""
         return self.translate(**kwargs)
 
     @staticmethod
-    def substitute_vars(value: str, **kwargs):
+    def substitute_vars(value: str, **kwargs) -> str:
         """Substitute vars in a translation
 
         Variables has to start with two braces (`{{`), followed by the variable
@@ -432,6 +458,10 @@ def add_missing_translation(
     public: bool = False,
 ) -> None:
     """Add missing translations to datastore"""
+
+    logging.error(f"{key=} {hint=} {default_text=} {filename=} {lineno=} {variables=} {public=}")
+    raise RuntimeError("ICH WILL DAS NICHT")
+
     try:
         from viur.core.modules.translation import TranslationSkel, Creator
     except ImportError as exc:

src/viur/core/modules/moduleconf.py

@@ -49,7 +49,7 @@ class ModuleConfScriptSkel(skeleton.RelSkel):
     access = SelectBone(
         descr="Required access rights",
         values=lambda: {
-            right: i18n.translate(f"viur.modules.user.accessright.{right}", defaultText=right)
+            right: i18n.translate(f"viur.core.modules.user.accessright.{right}", defaultText=right)
             for right in sorted(conf.user.access_rights)
         },
         multiple=True,

src/viur/core/modules/script.py

@@ -74,7 +74,7 @@ class ScriptLeafSkel(BaseScriptAbstractSkel):
     access = SelectBone(
         descr="Required access rights to run this Script",
         values=lambda: {
-            right: translate(f"viur.modules.user.accessright.{right}", defaultText=right)
+            right: translate(f"viur.core.modules.user.accessright.{right}", defaultText=right)
             for right in sorted(conf.user.access_rights)
         },
         multiple=True,