Allow passing jinja configuration and extensions

Author: ericof

src/tui_forms/_api.py

@@ -14,12 +14,16 @@ def create_renderer(
     renderer: str,
     schema: dict[str, Any],
     root_key: str = "",
+    jinja_config: dict[str, Any] | None = None,
+    jinja_extensions: list[str] | None = None,
 ) -> BaseRenderer:
     """Return a renderer configured with the parsed form, ready to call render().
 
     :param renderer: Name of the renderer to use (e.g. ``"stdlib"``, ``"rich"``).
     :param schema: The already-loaded JSONSchema dict describing the form.
     :param root_key: Optional key to nest all answers under in the returned dict.
+    :param jinja_config: Optional dict with configuration to be passed to Jinja2.
+    :param jinja_extensions: Optional list with extensions that need to be loaded.
     :raises ValueError: If the requested renderer name is not available.
     :raises jsonschema.ValidationError: If the schema does not conform to the
         expected form structure.
@@ -32,4 +36,4 @@ def create_renderer(
             f"Renderer {renderer!r} not found. Available renderers: {available}"
         )
     frm = jsonschema_to_form(schema, root_key=root_key)
-    return renderers[renderer](frm)
+    return renderers[renderer](frm, config=jinja_config, extensions=jinja_extensions)

src/tui_forms/renderer/base.py

@@ -21,14 +21,20 @@ class BaseRenderer(ABC):
     _form: form.Form
     _env: Environment
 
-    def __init__(self, frm: form.Form, config: dict[str, Any] | None = None) -> None:
+    def __init__(
+        self,
+        frm: form.Form,
+        config: dict[str, Any] | None = None,
+        extensions: list[str] | None = None,
+    ) -> None:
         """Initialise the renderer.
 
         :param frm: The form to render.
         :param config: Optional Jinja2 environment configuration.
+        :param extensions: Optional list of extensions to be loaded.
         """
         self._form = frm
-        self._env: Environment = create_environment(config)
+        self._env: Environment = create_environment(config, extensions=extensions)
 
     def render(self) -> dict[str, Any]:
         """Render the form and return the collected answers.

src/tui_forms/renderer/cookiecutter.py

@@ -11,13 +11,19 @@ class CookiecutterRenderer(BaseRenderer):
 
     name: str = "cookiecutter"
 
-    def __init__(self, form: Any, config: dict[str, Any] | None = None) -> None:
+    def __init__(
+        self,
+        form: Any,
+        config: dict[str, Any] | None = None,
+        extensions: list[str] | None = None,
+    ) -> None:
         """Initialise the renderer.
 
         :param form: The form to render.
         :param config: Optional Jinja2 environment configuration.
+        :param extensions: Optional list of extensions to be loaded.
         """
-        super().__init__(form, config)
+        super().__init__(form, config, extensions=extensions)
         self._console = Console()
 
     def _build_inline_prompt(

src/tui_forms/renderer/rich.py

@@ -19,13 +19,19 @@ class RichRenderer(BaseRenderer):
 
     name: str = "rich"
 
-    def __init__(self, form: Form, config: dict[str, Any] | None = None) -> None:
+    def __init__(
+        self,
+        form: Form,
+        config: dict[str, Any] | None = None,
+        extensions: list[str] | None = None,
+    ) -> None:
         """Initialise the renderer with a shared Rich Console.
 
         :param form: The form to render.
         :param config: Optional Jinja2 environment configuration.
+        :param extensions: Optional list of extensions to be loaded.
         """
-        super().__init__(form, config)
+        super().__init__(form, config, extensions=extensions)
         self._console = Console()
 
     def _show_panel(

src/tui_forms/utils/template.py

@@ -2,18 +2,25 @@
 from typing import Any
 
 
-def create_environment(config: dict[str, Any] | None) -> Environment:
+def create_environment(
+    config: dict[str, Any] | None, extensions: list[str] | None = None
+) -> Environment:
     """Create a Jinja2 Environment from an optional configuration dict.
 
     :param config: Optional config dict; the ``jinja2_environment`` key is
         merged into the Environment constructor kwargs if present.
     :return: A configured Jinja2 Environment.
     """
     env_kwargs: dict[str, Any] = {}
+    extensions = extensions if extensions else []
     if config is not None:
         env_kwargs.update(config.get("jinja2_environment", {}))
     env_kwargs.pop("autoescape", None)
-    return Environment(autoescape=True, **env_kwargs)
+    try:
+        env = Environment(autoescape=True, extensions=extensions, **env_kwargs)
+    except ImportError as err:
+        raise RuntimeError(f"Unable to load extension: {err}") from err
+    return env
 
 
 def render_variable(