rendr 0.1.5__tar.gz

rendr-0.1.5/.github/workflows/publish.yml

@@ -0,0 +1,35 @@
+name: Build and publish
+
+on:
+  push:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    environment:
+      name: pypi
+      url: https://pypi.org/p/rendr
+
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.x"
+
+      - name: Install build
+        run: python -m pip install --upgrade pip build
+
+      - name: Build distributions
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

rendr-0.1.5/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.5
+Name: rendr
+Version: 0.1.5
+Summary: A lightweight templating language inspired by Jinja2.
+Author-email: Mizuki Hikaru <mizuki@hikaru.org>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: mymarkup
+Description-Content-Type: text/markdown
+
+# rendr
+
+Please find the documentation at [hikaru.org](https://hikaru.org/projects/rendr).

rendr-0.1.5/README.md

@@ -0,0 +1,3 @@
+# rendr
+
+Please find the documentation at [hikaru.org](https://hikaru.org/projects/rendr).

rendr-0.1.5/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rendr"
+version = "0.1.5"
+description = "A lightweight templating language inspired by Jinja2."
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    { name="Mizuki Hikaru", email="mizuki@hikaru.org" },
+]
+dependencies = [
+    "mymarkup",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rendr"]

rendr-0.1.5/src/rendr/__init__.py

@@ -0,0 +1,324 @@
+import re
+import html
+import mymarkup
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Union
+
+
+class Undefined:
+    def __repr__(self):
+        return "Undefined"
+
+    def __bool__(self):
+        return False
+
+    def __str__(self):
+        return ""
+
+    def __iter__(self):
+        return iter(())
+
+    def __getattr__(self, name):
+        return self
+
+    def __getitem__(self, key):
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+
+class DotDict(dict):
+    def __getattribute__(self, name):
+        if name.startswith("__"):
+            return super().__getattribute__(name)
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            pass
+        if name in self:
+            return self[name]
+        return Undefined()
+
+    def __getitem__(self, key):
+        try:
+            return super().__getitem__(key)
+        except KeyError:
+            return Undefined()
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+
+def dot(value):
+    if isinstance(value, DotDict):
+        return value
+    if isinstance(value, dict):
+        return DotDict({key: dot(value) for key, value in value.items()})
+    if isinstance(value, list):
+        return [dot(value) for value in value]
+    if isinstance(value, tuple):
+        return tuple(dot(value) for value in value)
+    return value
+
+
+@dataclass
+class Markup:
+    html: str
+
+
+@dataclass
+class Context:
+    path: Optional[Path] = None
+    active_includes: list[Path] = field(default_factory=list)
+
+
+class Token:
+    subclasses = []
+
+    def __init_subclass__(cls):
+        Token.subclasses.append(cls)
+
+    @classmethod
+    def parse(cls, source: str, i: int) -> tuple["Token", int]:
+        for subclass in Token.subclasses:
+            token, ni = subclass.parse(source, i)
+            if token is not None:
+                return token, ni
+        raise Exception(f"No token matched position {i}: {source[i:i+30]!r}")
+
+
+@dataclass
+class Document:
+    children: list[Token]
+
+    @classmethod
+    def parse(cls, source: str) -> "Document":
+        children = []
+        i = 0
+        while i < len(source):
+            token, i = Token.parse(source, i)
+            children.append(token)
+        return Document(children)
+
+    def render(self, variables: DotDict, context: Context):
+        return "".join([x.render(variables, context) for x in self.children])
+
+
+@dataclass
+class Expr(Token):
+    expression: str
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{\{\s*(.+?)\s*\}\}")
+
+    @classmethod
+    def parse(cls, source: str, i: int) -> tuple[Optional["Expr"], int]:
+        match = Expr.opening_re().match(source, i)
+        if not match:
+            return None, i
+        return Expr(match.group(1)), match.end()
+
+    def render(self, variables: DotDict, context: Context):
+        value = eval(self.expression, variables)
+        if isinstance(value, Markup):
+            return value.html
+        return html.escape(str(value))
+
+
+@dataclass
+class Include(Token):
+    path: str
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{%\s*include\s+['\"]([^'\"]+)['\"]\s*%\}")
+
+    @classmethod
+    def parse(cls, source: str, i: int) -> tuple[Optional["Include"], int]:
+        match = Include.opening_re().match(source, i)
+        if not match:
+            return None, i
+        return Include(match.group(1)), match.end()
+
+    def render(self, variables, context):
+        if context.path is None:
+            raise Exception("{% include ... %} called without file path")
+        path = (context.path.parent / self.path).resolve()
+        if path in context.active_includes:
+            chain = " -> ".join(str(p) for p in context.active_includes) + " -> " + str(path)
+            raise Exception(f"Circular include detected: {chain}")
+        context.active_includes.append(path)
+        try:
+            source = path.read_text(encoding="utf-8")
+            return render(source, Context(path, context.active_includes), **variables)
+        finally:
+            context.active_includes.pop()
+
+
+class BlockTag:
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{%\s*(for|if)\s+(.+?)\s*%\}")
+
+    @classmethod
+    def closing_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{%\s*end(for|if)\s*%\}")
+
+    @classmethod
+    def else_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{%\s*else\s*%\}")
+
+    @classmethod
+    def extract_documents(cls, tag: str, source: str, i: int) -> tuple[Document, Document, int]:
+        document_strs = [""]
+        stack = []
+        while i < len(source):
+            opening_match = BlockTag.opening_re().match(source, i)
+            closing_match = BlockTag.closing_re().match(source, i)
+            else_match = BlockTag.else_re().match(source, i)
+            if opening_match:
+                stack.append(opening_match.group(1))
+                i = opening_match.end()
+                document_strs[-1] += opening_match.group(0)
+            elif closing_match:
+                closing_tag = closing_match.group(1)
+                if not stack:
+                    if closing_tag != tag:
+                        raise Exception(f"Closing tag mismatch: end{closing_tag}, expected end{tag}")
+                    if len(document_strs) < 2:
+                        document_strs.append("")
+                    documents = (
+                        Document.parse(document_strs[0]),
+                        Document.parse(document_strs[1]),
+                    )
+                    return (*documents, closing_match.end())
+                if closing_tag != stack[-1]:
+                    raise Exception(f"Closing tag mismatch: end{closing_tag}, expected end{stack[-1]}")
+                stack.pop()
+                i = closing_match.end()
+                document_strs[-1] += closing_match.group(0)
+            elif else_match:
+                if not stack:
+                    if tag != "if":
+                        raise Exception("For loop encountered else tag")
+                    if len(document_strs) > 1:
+                        raise Exception("Multiple else encountered")
+                    document_strs.append("")
+                else:
+                    if stack[-1] != "if":
+                        raise Exception("For loop encountered else tag")
+                    document_strs[-1] += else_match.group(0)
+                i = else_match.end()
+            else:
+                document_strs[-1] += source[i]
+                i += 1
+        raise Exception(f"Unclosed {{% {tag} %}}, missing {{% end{tag} %}}")
+
+
+@dataclass
+class For(Token):
+    names: list[str]
+    expression: str
+    document: Document
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{%\s*for\s+([A-Za-z_][A-Za-z0-9_]*(?:\s*,\s*[A-Za-z_][A-Za-z0-9_]*)*)\s+in\s+(.+?)\s*%\}")
+
+    @classmethod
+    def closing_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{%\s*endfor\s*%\}")
+
+    @classmethod
+    def parse(cls, source: str, i: int) -> tuple[Optional["For"], int]:
+        match = For.opening_re().match(source, i)
+        if not match:
+            return None, i
+        names = [x.strip() for x in match.group(1).split(",")]
+        expression = match.group(2)
+        body_start = match.end()
+        document, _, end = BlockTag.extract_documents("for", source, body_start)
+        return For(names, expression, document), end
+
+    def render(self, variables: DotDict, context: Context):
+        values = eval(self.expression, variables)
+        rendered = []
+        for value in values:
+            loop_variables = DotDict(variables)
+            if len(self.names) == 1:
+                loop_variables[self.names[0]] = dot(value)
+            else:
+                values = list(value)
+                if len(values) != len(self.names):
+                    raise Exception(f"Could not unpack loop value into {len(self.names)} variables")
+                for name, value in zip(self.names, values):
+                    loop_variables[name] = dot(value)
+            rendered.append(self.document.render(loop_variables, context))
+        return "".join(rendered)
+
+
+@dataclass
+class If(Token):
+    clause: str
+    then_document: Document
+    else_document: Document
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{%\s*if\s+(.+?)\s*%\}")
+
+    @classmethod
+    def closing_re(cls) -> re.Pattern[str]:
+        return re.compile(r"\{%\s*endif\s*%\}")
+
+    @classmethod
+    def parse(cls, source: str, i: int) -> tuple[Optional["If"], int]:
+        match = If.opening_re().match(source, i)
+        if not match:
+            return None, i
+        clause = match.group(1)
+        then_start = match.end()
+        then_document, else_document, end = BlockTag.extract_documents("if", source, then_start)
+        return If(clause, then_document, else_document), end
+
+    def render(self, variables: DotDict, context: Context):
+        if eval(self.clause, variables):
+            return self.then_document.render(variables, context)
+        return self.else_document.render(variables, context)
+
+
+@dataclass
+class Text(Token):
+    value: str
+
+    @classmethod
+    def parse(cls, source: str, i: int) -> tuple[Optional["Text"], int]:
+        j = i
+        while j < len(source):
+            if source[j:j+2] in ("{%", "{{"):
+                break
+            j += 1
+        if j == i:
+            return None, i
+        return Text(source[i:j]), j
+
+    def render(self, variables: DotDict, context: Context):
+        return self.value
+
+
+def parse(source: str) -> Document:
+    return Document.parse(source)
+
+
+def render(source: str, context: Context = Context(), **kwargs) -> str:
+    variables = dot(kwargs)
+    variables["mymarkup"] = lambda value: Markup(mymarkup.render(value))
+    return parse(source).render(variables, context)
+
+
+def render_file(path: Union[Path, str], **kwargs) -> str:
+    path = Path(path)
+    return render(path.read_text(encoding="utf-8"), Context(path), **kwargs)

rendr-0.1.5/src/rendr/tests.py

@@ -0,0 +1,307 @@
+from . import parse, render, Document, Text, Expr, Include, For, If
+
+
+def _single(doc: Document):
+    assert len(doc.children) == 1
+    return doc.children[0]
+
+
+def test_plain_text():
+    doc = parse("hello world")
+    assert isinstance(doc, Document)
+    assert len(doc.children) == 1
+    assert isinstance(doc.children[0], Text)
+    assert doc.children[0].value == "hello world"
+
+
+def test_text_with_whitespace():
+    doc = parse("  line one\n  line two  ")
+    node = _single(doc)
+    assert isinstance(node, Text)
+    assert node.value == "  line one\n  line two  "
+
+
+def test_empty():
+    doc = parse("")
+    assert isinstance(doc, Document)
+    assert doc.children == []
+
+
+def test_simple_expression():
+    doc = parse("{{ name }}")
+    node = _single(doc)
+    assert isinstance(node, Expr)
+    assert node.expression == "name"
+
+
+def test_expression_no_spaces():
+    doc = parse("{{name}}")
+    node = _single(doc)
+    assert isinstance(node, Expr)
+    assert node.expression == "name"
+
+
+def test_expression_dotted():
+    doc = parse("{{ user.name }}")
+    node = _single(doc)
+    assert isinstance(node, Expr)
+    assert node.expression == "user.name"
+
+
+def test_expression_surrounded_by_text():
+    doc = parse("Hello {{ name }}!")
+    assert len(doc.children) == 3
+    assert isinstance(doc.children[0], Text) and doc.children[0].value == "Hello "
+    assert isinstance(doc.children[1], Expr) and doc.children[1].expression == "name"
+    assert isinstance(doc.children[2], Text) and doc.children[2].value == "!"
+
+
+def test_multiple_expressions():
+    doc = parse("{{ a }} and {{ b }}")
+    assert len(doc.children) == 3
+    assert isinstance(doc.children[0], Expr) and doc.children[0].expression == "a"
+    assert isinstance(doc.children[1], Text) and doc.children[1].value == " and "
+    assert isinstance(doc.children[2], Expr) and doc.children[2].expression == "b"
+
+
+def test_include():
+    doc = parse("{% include 'header.html' %}")
+    node = _single(doc)
+    assert isinstance(node, Include)
+    assert node.path == "header.html"
+
+
+def test_include_double_quotes():
+    doc = parse('{% include "styles.css" %}')
+    node = _single(doc)
+    assert isinstance(node, Include)
+    assert node.path == "styles.css"
+
+
+def test_include_between_text():
+    doc = parse("before{% include 'x.html' %}after")
+    assert len(doc.children) == 3
+    assert isinstance(doc.children[0], Text) and doc.children[0].value == "before"
+    assert isinstance(doc.children[1], Include) and doc.children[1].path == "x.html"
+    assert isinstance(doc.children[2], Text) and doc.children[2].value == "after"
+
+
+def test_for_simple():
+    doc = parse("{% for x in items %}{{ x }}{% endfor %}")
+    node = _single(doc)
+    assert isinstance(node, For)
+    assert node.names == ["x"]
+    assert node.expression == "items"
+    assert isinstance(node.document, Document)
+    body_child = _single(node.document)
+    assert isinstance(body_child, Expr) and body_child.expression == "x"
+
+
+def test_for_with_text_around():
+    doc = parse("start {% for n in ns %}{{ n }}{% endfor %} end")
+    assert len(doc.children) == 3
+    assert isinstance(doc.children[0], Text) and doc.children[0].value == "start "
+    assert isinstance(doc.children[1], For)
+    assert isinstance(doc.children[2], Text) and doc.children[2].value == " end"
+    loop = doc.children[1]
+    assert loop.names == ["n"]
+    assert loop.expression == "ns"
+    inner = _single(loop.document)
+    assert isinstance(inner, Expr) and inner.expression == "n"
+
+
+def test_for_tuple_unpack():
+    doc = parse("{% for k, v in d.items() %}{{ k }}:{{ v }}{% endfor %}")
+    loop = _single(doc)
+    assert isinstance(loop, For)
+    assert loop.names == ["k", "v"]
+    assert loop.expression == "d.items()"
+    assert len(loop.document.children) == 3
+    assert isinstance(loop.document.children[0], Expr) and loop.document.children[0].expression == "k"
+    assert isinstance(loop.document.children[1], Text) and loop.document.children[1].value == ":"
+    assert isinstance(loop.document.children[2], Expr) and loop.document.children[2].expression == "v"
+
+
+def test_for_nested():
+    doc = parse(
+        "{% for row in rows %}{% for col in row %}{{ col }}{% endfor %}{% endfor %}"
+    )
+    outer = _single(doc)
+    assert isinstance(outer, For) and outer.names == ["row"] and outer.expression == "rows"
+    inner = _single(outer.document)
+    assert isinstance(inner, For) and inner.names == ["col"] and inner.expression == "row"
+    cell = _single(inner.document)
+    assert isinstance(cell, Expr) and cell.expression == "col"
+
+
+def test_for_inside_if():
+    doc = parse(
+        "{% if ok %}{% for x in xs %}{{ x }}{% endfor %}{% endif %}"
+    )
+    cond = _single(doc)
+    assert isinstance(cond, If) and cond.clause == "ok"
+    loop = _single(cond.then_document)
+    assert isinstance(loop, For) and loop.names == ["x"] and loop.expression == "xs"
+    inner = _single(loop.document)
+    assert isinstance(inner, Expr) and inner.expression == "x"
+    assert isinstance(cond.else_document, Document)
+    assert cond.else_document.children == []
+
+
+def test_if_true_branch_only():
+    doc = parse("{% if visible %}shown{% endif %}")
+    cond = _single(doc)
+    assert isinstance(cond, If)
+    assert cond.clause == "visible"
+    then_text = _single(cond.then_document)
+    assert isinstance(then_text, Text) and then_text.value == "shown"
+    assert isinstance(cond.else_document, Document)
+    assert cond.else_document.children == []
+
+
+def test_if_with_else():
+    doc = parse("{% if ok %}yes{% else %}no{% endif %}")
+    cond = _single(doc)
+    assert isinstance(cond, If) and cond.clause == "ok"
+    assert _single(cond.then_document).value == "yes"
+    assert _single(cond.else_document).value == "no"
+
+
+def test_if_with_complex_else():
+    doc = parse(
+        "{% if user %}Hello {{ user.name }}{% else %}Please {% include 'login.html' %}{% endif %}"
+    )
+    cond = _single(doc)
+    assert isinstance(cond, If) and cond.clause == "user"
+    assert len(cond.then_document.children) == 2
+    assert isinstance(cond.then_document.children[0], Text) and cond.then_document.children[0].value == "Hello "
+    assert isinstance(cond.then_document.children[1], Expr) and cond.then_document.children[1].expression == "user.name"
+    assert len(cond.else_document.children) == 2
+    assert isinstance(cond.else_document.children[0], Text) and cond.else_document.children[0].value == "Please "
+    assert isinstance(cond.else_document.children[1], Include) and cond.else_document.children[1].path == "login.html"
+
+
+def test_nested_if_else_inside_for():
+    doc = parse(
+        "{% for item in items %}{% if item.done %}done{% else %}todo{% endif %}{% endfor %}"
+    )
+    loop = _single(doc)
+    assert isinstance(loop, For) and loop.names == ["item"] and loop.expression == "items"
+    cond = _single(loop.document)
+    assert isinstance(cond, If) and cond.clause == "item.done"
+    assert _single(cond.then_document).value == "done"
+    assert _single(cond.else_document).value == "todo"
+
+
+def test_if_else_ignores_else_inside_nested_for():
+    doc = parse(
+        "{% if flag %}{% for x in xs %}{% if x %}{% else %}{% endif %}{% endfor %}{% else %}outer{% endif %}"
+    )
+    cond = _single(doc)
+    assert isinstance(cond, If) and cond.clause == "flag"
+    assert _single(cond.else_document).value == "outer"
+    inner_loop = _single(cond.then_document)
+    assert isinstance(inner_loop, For) and inner_loop.names == ["x"] and inner_loop.expression == "xs"
+
+
+def test_render():
+    template = """
+        {{ user.name }}
+
+        {% if user.active %}
+            Hello {{ user.name }}
+        {% endif %}
+
+        {% for user in users %}
+            {{ user.name }}
+        {% endfor %}
+
+        {% for key, value in values.items() %}
+            {{ key }} = {{ value }}
+        {% endfor %}
+    """
+
+    variables = {
+        "user": {"name": "Alice", "active": True},
+        "users": [
+            {"name": "Bob"},
+            {"name": "Charlie"},
+            {"name": "Diana"},
+        ],
+        "values": {"a": 1, "b": 2, "c": 3},
+    }
+
+    expected = """
+        Alice
+
+        
+            Hello Alice
+        
+
+        
+            Bob
+        
+            Charlie
+        
+            Diana
+        
+
+        
+            a = 1
+        
+            b = 2
+        
+            c = 3
+        
+    """
+
+    assert render(template, **variables) == expected
+
+
+def test_render_if_else_and_inactive():
+    assert render("{% if ok %}yes{% else %}no{% endif %}", ok=True) == "yes"
+    assert render("{% if ok %}yes{% else %}no{% endif %}", ok=False) == "no"
+
+    template_inactive = """
+        {{ user.name }}
+        {% if user.active %}Should NOT appear{% endif %}
+    """
+
+    expected_inactive = """
+        Eve
+        
+    """
+
+    assert render(template_inactive, user={"name": "Eve", "active": False}) == expected_inactive
+
+
+def main():
+    test_plain_text()
+    test_text_with_whitespace()
+    test_empty()
+    test_simple_expression()
+    test_expression_no_spaces()
+    test_expression_dotted()
+    test_expression_surrounded_by_text()
+    test_multiple_expressions()
+    test_include()
+    test_include_double_quotes()
+    test_include_between_text()
+    test_for_simple()
+    test_for_with_text_around()
+    test_for_tuple_unpack()
+    test_for_nested()
+    test_for_inside_if()
+    test_if_true_branch_only()
+    test_if_with_else()
+    test_if_with_complex_else()
+    test_nested_if_else_inside_for()
+    test_if_else_ignores_else_inside_nested_for()
+    test_render()
+    test_render_if_else_and_inactive()
+
+    print("All tests passed")
+
+
+if __name__ == "__main__":
+    main()