Refactor to make template rendering configurable

- Add `template_renderers` setting and make `render_highlight`
  the built-in default, so `<highlight>` is still rendered
- Add `template_filters` setting and make a new filter
  `wordwrap` available by default (these filters can also be
  used as regular functions, sitting in processing.py for
  custom processing)
- Adjust tests, add wordwrap tests

Author: dannyadair

src/pdfbaker/baker.py

@@ -25,6 +25,10 @@
         "build": "build",
         "dist": "dist",
     },
+    # Highlighting support enabled by default
+    "template_renderers": ["render_highlight"],
+    # Make all filters available by default
+    "template_filters": ["wordwrap"],
 }
 
 

src/pdfbaker/page.py

@@ -99,6 +99,7 @@ def process(self) -> Path:
             jinja_env = create_env(
                 templates_dir=self.config.template.parent,
                 extensions=jinja_extensions,
+                template_filters=self.config.get("template_filters", []),
             )
             template = jinja_env.get_template(self.config.template.name)
         except TemplateNotFound as exc:
@@ -122,7 +123,10 @@ def process(self) -> Path:
 
         self.log_debug("Rendering template...")
         try:
-            rendered_template = template.render(**template_context)
+            rendered_template = template.render(
+                **template_context,
+                renderers=self.config.get("template_renderers", []),
+            )
             with open(output_svg, "w", encoding="utf-8") as f:
                 f.write(rendered_template)
         except TemplateError as exc:

src/pdfbaker/processing.py

@@ -0,0 +1,37 @@
+"""Helper functions for custom processing."""
+
+
+def wordwrap(text: str, max_chars: int = 60) -> list[str]:
+    """Split text into lines with a maximum width, breaking at word boundaries.
+
+    Args:
+        text: The text to wrap
+        max_chars: Maximum number of characters per line
+
+    Returns:
+        List of strings, one for each line
+    """
+    if not text:
+        return []
+
+    words = text.split()
+    lines = []
+    current_line = []
+    current_width = 0
+
+    for word in words:
+        if current_width + len(word) + int(current_width > 0) <= max_chars:
+            # Word still fits in current line
+            current_line.append(word)
+            current_width += len(word) + int(current_width > 0)
+        else:
+            # Word is too long, start a new line
+            if current_line:
+                lines.append(" ".join(current_line))
+            current_line = [word]
+            current_width = len(word)
+
+    if current_line:
+        lines.append(" ".join(current_line))
+
+    return lines

src/pdfbaker/render.py

@@ -8,39 +8,66 @@
 
 import jinja2
 
+from . import processing
+from .config import render_config
 from .types import ImageSpec, StyleDict
 
 __all__ = [
     "create_env",
+    "PDFBakerTemplate",
     "prepare_template_context",
 ]
 
 
-class HighlightingTemplate(jinja2.Template):  # pylint: disable=too-few-public-methods
-    """A Jinja template that automatically applies highlighting to text.
+class PDFBakerTemplate(jinja2.Template):  # pylint: disable=too-few-public-methods
+    """A Jinja template with custom rendering capabilities for PDFBaker.
 
-    This template class extends the base Jinja template to automatically
-    convert <highlight> tags to styled <tspan> elements with the highlight color.
+    This template class extends the base Jinja template to apply
+    additional rendering transformations to the template output.
     """
 
     def render(self, *args: Any, **kwargs: Any) -> str:
-        """Render the template and apply highlighting to the result."""
-        rendered = super().render(*args, **kwargs)
+        """Render the template and apply custom transformations.
 
-        if "style" in kwargs and "highlight_color" in kwargs["style"]:
-            highlight_color = kwargs["style"]["highlight_color"]
+        Args:
+            *args: Positional arguments for template rendering
+            **kwargs: Keyword arguments for template rendering
+                renderers: Optional list of renderer function names to apply
 
-            def replacer(match: re.Match[str]) -> str:
-                content = match.group(1)
-                return f'<tspan style="fill:{highlight_color}">{content}</tspan>'
+        Returns:
+            Rendered template with transformations applied
+        """
+        rendered = super().render(*args, **kwargs)
 
-            rendered = re.sub(r"<highlight>(.*?)</highlight>", replacer, rendered)
+        for renderer_name in kwargs.get("renderers", []):
+            renderer_func = globals().get(renderer_name)
+            if callable(renderer_func):
+                rendered = renderer_func(rendered, **kwargs)
 
         return rendered
 
 
+def render_highlight(rendered: str, **kwargs: Any) -> str:
+    """Apply highlight tags to the rendered template content.
+
+    Convert <highlight> tags to styled <tspan> elements with the highlight color.
+    """
+    if "style" in kwargs and "highlight_color" in kwargs["style"]:
+        highlight_color = kwargs["style"]["highlight_color"]
+
+        def replacer(match: re.Match[str]) -> str:
+            content = match.group(1)
+            return f'<tspan style="fill:{highlight_color}">{content}</tspan>'
+
+        rendered = re.sub(r"<highlight>(.*?)</highlight>", replacer, rendered)
+
+    return rendered
+
+
 def create_env(
-    templates_dir: Path | None = None, extensions: list[str] | None = None
+    templates_dir: Path | None = None,
+    extensions: list[str] | None = None,
+    template_filters: list[str] | None = None,
 ) -> jinja2.Environment:
     """Create and configure the Jinja environment."""
     if templates_dir is None:
@@ -51,20 +78,29 @@ def create_env(
         autoescape=jinja2.select_autoescape(),
         extensions=extensions or [],
     )
-    env.template_class = HighlightingTemplate
+    env.template_class = PDFBakerTemplate
+
+    if template_filters:
+        for filter_name in template_filters:
+            if hasattr(processing, filter_name):
+                env.filters[filter_name] = getattr(processing, filter_name)
+
     return env
 
 
 def prepare_template_context(
     config: dict[str], images_dir: Path | None = None
 ) -> dict[str]:
-    """Prepare config for template rendering by resolving styles and encoding images.
+    """Prepare template context with variables/styles/images
+
+    Resolves variables, styles and encodes images.
 
     Args:
         config: Configuration with optional styles and images
         images_dir: Directory containing images to encode
     """
-    context = config.copy()
+    # Render configuration to resolve template strings inside strings
+    context = render_config(config)
 
     # Resolve style references to actual theme colors
     if "style" in context and "theme" in context:

tests/test_processing.py

@@ -0,0 +1,71 @@
+"""Tests for processing functions."""
+
+from pdfbaker.processing import wordwrap
+
+
+def test_wordwrap_empty_input():
+    """Test wordwrap with empty inputs."""
+    assert not wordwrap("")
+    assert not wordwrap(" ")
+    assert not wordwrap("   ")
+
+
+def test_wordwrap_normal_text():
+    """Test wordwrap with normal text."""
+    text = "This is a simple test for word wrapping functionality."
+    # Max width 20 chars
+    expected = ["This is a simple", "test for word", "wrapping", "functionality."]
+    assert wordwrap(text, max_chars=20) == expected
+
+    # Default max width (60 chars)
+    assert wordwrap(text) == [text]  # Should fit on one line with default width
+
+
+def test_wordwrap_long_words():
+    """Test wordwrap with words longer than the max width."""
+    # Single word longer than max width
+    assert wordwrap("supercalifragilisticexpialidocious", max_chars=10) == [
+        "supercalifragilisticexpialidocious"
+    ]
+
+    # Mixed text with one long word
+    text = "This has a supercalifragilisticexpialidocious word in it."
+    expected = ["This has a", "supercalifragilisticexpialidocious", "word in it."]
+    assert wordwrap(text, max_chars=15) == expected
+
+
+def test_wordwrap_edge_cases():
+    """Test wordwrap with various edge cases."""
+    # Text with exactly max width
+    assert wordwrap("1234567890", max_chars=10) == ["1234567890"]
+
+    # Text with multiple spaces
+    assert wordwrap("word1    word2", max_chars=20) == ["word1 word2"]
+
+    # Line just at the boundary
+    text = "one two three four"
+    assert wordwrap(text, max_chars=13) == ["one two three", "four"]
+
+    # Really large max_chars
+    assert wordwrap("short text", max_chars=1000) == ["short text"]
+
+
+def test_wordwrap_newlines():
+    """Test that newlines in the input are treated as spaces."""
+    text = "Line one\nLine two\nLine three"
+    expected = ["Line one Line two", "Line three"]
+    assert wordwrap(text, max_chars=20) == expected
+
+
+def test_wordwrap_long_word_with_following_words():
+    """Test that processing continues after a long word."""
+    text = "supercalifragilisticexpialidocious is followed by more words"
+    result = wordwrap(text, 10)
+
+    assert result == [
+        "supercalifragilisticexpialidocious",
+        "is",
+        "followed",
+        "by more",
+        "words",
+    ]

tests/test_render.py

@@ -7,7 +7,7 @@
 import pytest
 
 from pdfbaker.render import (
-    HighlightingTemplate,
+    PDFBakerTemplate,
     create_env,
     encode_image,
     encode_images,
@@ -20,7 +20,7 @@ def test_create_env(tmp_path: Path) -> None:
     """Test creating Jinja environment."""
     env = create_env(tmp_path)
     assert isinstance(env, jinja2.Environment)
-    assert env.template_class == HighlightingTemplate
+    assert env.template_class == PDFBakerTemplate
     assert isinstance(env.loader, jinja2.FileSystemLoader)
 
 
@@ -33,15 +33,20 @@ def test_create_env_no_directory() -> None:
 # Template rendering tests
 def test_highlighting_template() -> None:
     """Test highlighting template functionality."""
-    template = HighlightingTemplate("<highlight>test</highlight>")
-    result = template.render(style={"highlight_color": "red"})
+    template = PDFBakerTemplate("<highlight>test</highlight>")
+    result = template.render(
+        renderers=["render_highlight"], style={"highlight_color": "red"}
+    )
     assert result == '<tspan style="fill:red">test</tspan>'
 
 
-def test_highlighting_template_no_highlight() -> None:
+def test_highlighting_template_no_style() -> None:
     """Test highlighting template with no highlight color."""
-    template = HighlightingTemplate("<highlight>test</highlight>")
-    result = template.render()  # No style provided
+    template = PDFBakerTemplate("<highlight>test</highlight>")
+    result = template.render(
+        renderers=["render_highlight"],
+        # No style provided
+    )
     assert result == "<highlight>test</highlight>"