python-fragments 0.29__tar.gz → 0.31__tar.gz

{python_fragments-0.29 → python_fragments-0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fragments
-Version: 0.29
+Version: 0.31
 Summary: Modern HTML template rendering in Python
 Author-email: The Running Algorithm <services@therunningalgorithm.info>
 License: MIT License

{python_fragments-0.29 → python_fragments-0.31}/fragments/ast_nodes.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 from typing import Sequence
 
-type ASTHTMLChild = ASTHTMLElement | ASTHTMLComment | ASTHTMLText | ASTInterpolation | ASTComponent | ASTControlNode | ASTDoctype
+type ASTHTMLChild = ASTHTMLElement | ASTHTMLComment | ASTHTMLText | ASTInterpolation | ASTComponent | ASTControlNode | ASTDoctype | ASTChildrenSlot
 
 
 @dataclass(slots=True)
@@ -15,7 +15,7 @@ class ASTModule:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __template__: str = "from fragments.html.elements import el, sequence, comment\n{}"
+    __template__: str = "from fragments.html.elements import el, _sequence, comment\n{}"
 
     def transpile(self, transpiled_start: int = 0) -> None:
         """Build transpiled outputs for the module."""
@@ -83,18 +83,15 @@ class ASTFragment:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __template__: str = """sequence([{}])"""
-
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
-        transpiled_start += 10
         for child in self.children:
             child.transpile(transpiled_start)
             transpiled_start = child.transpiled_end + 1
-        if len(self.children) > 0:
+        if self.children:
             transpiled_start -= 1
 
-        self.transpiled_content = self.__template__.format(",".join(child.transpiled_content for child in self.children))
+        self.transpiled_content = "+".join(child.transpiled_content for child in self.children) if self.children else '""'
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -126,26 +123,28 @@ class ASTHTMLElement:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __element_template__: str = """el("{}",[{}],oneline={},attributes={})"""
+    __element_template__: str = """el("{}",{},oneline={},attributes={})"""
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
-        transpiled_start = transpiled_start + len(self.name) + 7
+        transpiled_start = transpiled_start + len(self.name) + 6  # el("name",
         for child in self.children:
             child.transpile(transpiled_start)
             transpiled_start = child.transpiled_end + 1
-        if len(self.children) > 0:
+        if self.children:
             transpiled_start -= 1
-        children = ",".join(child.transpiled_content for child in self.children)
+        children_expr = "+".join(child.transpiled_content for child in self.children) if self.children else '""'
+        if not self.children:
+            transpiled_start += 2  # ""
         oneline_offset = len(str(self.one_line))
-        transpiled_start += 10 + oneline_offset + 12 + 1  # ],oneline= + oneline + ,attributes= + {
+        transpiled_start += 9 + oneline_offset + 12 + 1  # ,oneline= + oneline + ,attributes= + {
         for attribute in self.attributes.values():
             attribute.transpile(transpiled_start)
             transpiled_start = attribute.transpiled_end + 1
         transpiled_start -= 1
 
         attributes = "{" + ",".join(attribute.transpiled_content for attribute in self.attributes.values()) + "}"
-        self.transpiled_content = self.__element_template__.format(self.name, children, self.one_line, attributes)
+        self.transpiled_content = self.__element_template__.format(self.name, children_expr, self.one_line, attributes)
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -184,18 +183,18 @@ class ASTControlNode[T: (ASTHTMLElement, ASTComponent)]:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __for_template__: str = "sequence([{} for {}])"
-    __if_template__: str = "{} if {} else ''"
+    __for_template__: str = "_sequence([{} for {}])"
+    __if_template__: str = "({} if {} else '')"
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
         if self.for_interpolation is not None:
-            self.child.transpile(transpiled_start + 10)  # sequence([
+            self.child.transpile(transpiled_start + 11)  # _sequence([
             self.for_interpolation.transpile(self.child.transpiled_end + 5)  # child +  for
             self.transpiled_content = self.__for_template__.format(self.child.transpiled_content, self.for_interpolation.transpiled_content)
         elif self.if_interpolation is not None:
-            self.child.transpile(transpiled_start)
-            self.if_interpolation.transpile(self.child.transpiled_end + 4)  # child +  if
+            self.child.transpile(transpiled_start + 1)  # ( before child
+            self.if_interpolation.transpile(self.child.transpiled_end + 4)  # " if "
             self.transpiled_content = self.__if_template__.format(self.child.transpiled_content, self.if_interpolation.transpiled_content)
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
@@ -250,25 +249,27 @@ class ASTComponent:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __template__: str = """{}([{}],{})"""
+    __template__: str = """{}({},{})"""
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
         self.name.transpile(self.transpiled_start)
-        transpiled_start = self.name.transpiled_end + 2
+        transpiled_start = self.name.transpiled_end + 1  # (
         for child in self.children:
             child.transpile(transpiled_start)
-            transpiled_start = child.transpiled_end + 1
+            transpiled_start = child.transpiled_end + 1  # + between children
         if self.children:
             transpiled_start -= 1
-        children = ",".join(child.transpiled_content for child in self.children)
+        children = "+".join(child.transpiled_content for child in self.children) if self.children else '""'
+        if not self.children:
+            transpiled_start += 2  # ""
 
         if len(self.arguments) == 0:
             self.transpiled_content = self.__template__.format(self.name.transpiled_content, children, "")
             self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
             return
 
-        transpiled_start += 2
+        transpiled_start += 1  # , before arguments
         for attribute in self.arguments.values():
             attribute.transpile(transpiled_start)
             transpiled_start = attribute.transpiled_end + 1
@@ -546,3 +547,24 @@ class ASTInterpolation:
             return self.source_start + specific_offset + 2 + self.leading_whitespace
 
         return None
+
+
+@dataclass(slots=True)
+class ASTChildrenSlot:
+    source_start: int = field(compare=False)
+    source_end: int = field(compare=False)
+
+    transpiled_content: str = field(init=False)
+    transpiled_start: int = field(init=False)
+    transpiled_end: int = field(init=False)
+
+    def transpile(self, transpiled_start: int) -> None:
+        self.transpiled_start = transpiled_start
+        self.transpiled_content = "children"
+        self.transpiled_end = transpiled_start + len("children")
+
+    def map_offset(self, offset: int) -> None:
+        return None
+
+    def unmap_offset(self, offset: int) -> None:
+        return None

{python_fragments-0.29 → python_fragments-0.31}/fragments/grammar.py

@@ -2,6 +2,7 @@ from re import Match
 import re
 
 from fragments.ast_nodes import (
+    ASTChildrenSlot,
     ASTComponent,
     ASTComponentArgument,
     ASTComponentName,
@@ -22,7 +23,6 @@ from fragments.source import Source
 HTML_IDENTIFIER = r"[a-zA-Z][a-zA-Z0-9_:.-]*"
 HTML_ATTRIBUTE_NAME = r"[a-zA-Z:-_][a-zA-Z0-9_:.-]*"
 HTML_TEXT = r"([\s\S]*?)(?=<|{{)"
-CHILDREN_META_COMPONENT = r"<[\S]*Children\.\.\.[\S]*/>"
 
 
 class ParsingError(Exception):
@@ -103,7 +103,9 @@ def expect_fragment(source: Source) -> tuple[Source, ASTFragment]:
 
     children: list[ASTHTMLChild] = []
     while not source.remaining().startswith("</>"):
-        source, _ = source.eat_whitespace()
+        source_after_whitespace, _ = source.eat_whitespace()
+        if source_after_whitespace.remaining().startswith("<"):
+            source = source_after_whitespace
         if source.remaining().startswith("</>"):
             break
         source, child = expect_child(source)
@@ -116,6 +118,12 @@ def expect_fragment(source: Source) -> tuple[Source, ASTFragment]:
     return source, ASTFragment(source_start, source_end, children)
 
 
+def expect_children_slot(source: Source) -> tuple[Source, ASTChildrenSlot]:
+    source_start = source.offset
+    source = expect_string(source, "<Children... />")
+    return source, ASTChildrenSlot(source_start, source.offset)
+
+
 def expect_child(source: Source) -> tuple[Source, ASTHTMLChild]:
     """Any HTML / functional block that might appear as part of the fragment."""
     if source.remaining().startswith("<!DOCTYPE html>"):
@@ -126,6 +134,10 @@ def expect_child(source: Source) -> tuple[Source, ASTHTMLChild]:
         source, html_comment = expect_html_comment(source)
         return source, html_comment
 
+    if source.remaining().startswith("<Children... />"):
+        source, children_slot = expect_children_slot(source)
+        return source, children_slot
+
     if source.start_matches(r"<[A-Z]"):
         source, component = expect_component(source)
         return source, component
@@ -281,7 +293,7 @@ def expect_children(source: Source) -> tuple[Source, list[ASTHTMLChild]]:
         source, child = expect_child(source)
         children.append(child)
         source_after_whitespace, _ = source.eat_whitespace()
-        if not source_after_whitespace.remaining().startswith("{{"):
+        if source_after_whitespace.remaining().startswith("<"):
             source = source_after_whitespace
     return source, children
 

{python_fragments-0.29 → python_fragments-0.31}/fragments/html/elements.py

@@ -1,11 +1,11 @@
 import json
 from typing import Any
-from fragments.types import Children
+from fragments.types import Children, Stringable
 import html
 
 
-def sequence(children: Children) -> str:
-    return "".join(str(child) for child in children)
+def _sequence(items: list[str | Stringable]) -> str:
+    return "".join(str(item) for item in items)
 
 
 def el(
@@ -26,9 +26,7 @@ def el(
     if oneline:
         return f"""<{tag_contents_string} />"""
 
-    children_string = sequence(children)
-
-    return f"""<{tag_contents_string}>{children_string}</{name}>"""
+    return f"""<{tag_contents_string}>{children}</{name}>"""
 
 
 def comment(content: str) -> str:

{python_fragments-0.29 → python_fragments-0.31}/fragments/types.py

@@ -5,5 +5,4 @@ class Stringable(Protocol):
     def __str__(self) -> str: ...
 
 
-type Child = str | Stringable
-type Children = list[Child]
+type Children = str

{python_fragments-0.29 → python_fragments-0.31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-fragments"
-version = "0.29"
+version = "0.31"
 description = "Modern HTML template rendering in Python"
 authors = [{ name = "The Running Algorithm", email = "services@therunningalgorithm.info" }]
 readme = "README.md"

{python_fragments-0.29 → python_fragments-0.31}/python_fragments.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fragments
-Version: 0.29
+Version: 0.31
 Summary: Modern HTML template rendering in Python
 Author-email: The Running Algorithm <services@therunningalgorithm.info>
 License: MIT License

{python_fragments-0.29 → python_fragments-0.31}/python_fragments.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ python_fragments.egg-info/dependency_links.txt
 python_fragments.egg-info/entry_points.txt
 python_fragments.egg-info/requires.txt
 python_fragments.egg-info/top_level.txt
+tests/test_end_to_end.py
 tests/test_grammar.py
 tests/test_html_elements.py
 tests/test_source_map.py

python_fragments-0.31/tests/test_end_to_end.py

@@ -0,0 +1,158 @@
+from fragments.grammar import expect_module
+from fragments.source import Source
+
+
+def render(source_str: str, **variables: object) -> str:
+    """Transpile a fragment source string, execute it, and return the result."""
+    source = Source.from_string(f"result = {source_str.strip()}")
+    _, module = expect_module(source)
+    module.transpile(0)
+    namespace: dict[str, object] = dict(variables)
+    exec(module.transpiled_content, namespace)
+    return str(namespace["result"])
+
+
+# ---------------------------------------------------------------------------
+# Basic elements
+# ---------------------------------------------------------------------------
+
+
+def test_single_element():
+    assert render("<><h1>Hello</h1></>") == "<h1>Hello</h1>"
+
+
+def test_multiple_siblings():
+    assert render("<><h1>Title</h1><p>Body</p></>") == "<h1>Title</h1><p>Body</p>"
+
+
+def test_nested_elements():
+    assert render("<><div><p>text</p></div></>") == "<div><p>text</p></div>"
+
+
+def test_self_closing_element():
+    assert render("<><br /></>") == "<br />"
+
+
+def test_empty_fragment():
+    assert render('<></>') == ""
+
+
+# ---------------------------------------------------------------------------
+# Interpolation
+# ---------------------------------------------------------------------------
+
+
+def test_interpolation():
+    assert render("<><p>{{ name }}</p></>", name="World") == "<p>World</p>"
+
+
+def test_multiple_interpolations():
+    assert render("<><p>{{ a }} and {{ b }}</p></>", a="foo", b="bar") == "<p>foo and bar</p>"
+
+
+def test_text_space_before_element():
+    assert render("<>Icon: <i></i></>") == "Icon: <i></i>"
+
+
+def test_text_space_after_element():
+    assert render("<><i></i> text</>") == "<i></i> text"
+
+
+def test_text_space_around_element():
+    assert render("<>before <i>em</i> after</>") == "before <i>em</i> after"
+
+
+# ---------------------------------------------------------------------------
+# Control flow — if
+# ---------------------------------------------------------------------------
+
+
+def test_if_true():
+    assert render("<><p if={{ cond }}>yes</p></>", cond=True) == "<p>yes</p>"
+
+
+def test_if_false():
+    assert render("<><p if={{ cond }}>yes</p></>", cond=False) == ""
+
+
+def test_if_true_with_sibling():
+    result = render("<><p if={{ cond }}>yes</p><p>always</p></>", cond=True)
+    assert result == "<p>yes</p><p>always</p>"
+
+
+def test_if_false_with_sibling():
+    result = render("<><p if={{ cond }}>yes</p><p>always</p></>", cond=False)
+    assert result == "<p>always</p>"
+
+
+def test_if_true_with_preceding_sibling():
+    result = render("<><p>always</p><p if={{ cond }}>maybe</p></>", cond=True)
+    assert result == "<p>always</p><p>maybe</p>"
+
+
+def test_if_false_with_preceding_sibling():
+    result = render("<><p>always</p><p if={{ cond }}>maybe</p></>", cond=False)
+    assert result == "<p>always</p>"
+
+
+def test_if_between_siblings():
+    result = render("<><p>before</p><p if={{ cond }}>maybe</p><p>after</p></>", cond=True)
+    assert result == "<p>before</p><p>maybe</p><p>after</p>"
+
+    result = render("<><p>before</p><p if={{ cond }}>maybe</p><p>after</p></>", cond=False)
+    assert result == "<p>before</p><p>after</p>"
+
+
+# ---------------------------------------------------------------------------
+# Control flow — for
+# ---------------------------------------------------------------------------
+
+
+def test_for_loop():
+    result = render("<><li for={{ item in items }}>{{ item }}</li></>", items=["a", "b", "c"])
+    assert result == "<li>a</li><li>b</li><li>c</li>"
+
+
+def test_for_loop_with_sibling():
+    result = render("<><h1>List</h1><li for={{ item in items }}>{{ item }}</li></>", items=["x", "y"])
+    assert result == "<h1>List</h1><li>x</li><li>y</li>"
+
+
+def test_for_loop_empty():
+    assert render("<><li for={{ item in items }}>{{ item }}</li></>", items=[]) == ""
+
+
+# ---------------------------------------------------------------------------
+# Components
+# ---------------------------------------------------------------------------
+
+
+def test_component_no_children():
+    def Badge(children: str, label: str) -> str:
+        return f"<span>{label}</span>"
+
+    result = render("<><Badge label=\"hi\" /></>", Badge=Badge)
+    assert result == "<span>hi</span>"
+
+
+def test_component_with_children():
+    from fragments.types import Children
+
+    def Wrapper(children: Children) -> str:
+        return f"<div>{children}</div>"
+
+    result = render("<><Wrapper><p>content</p></Wrapper></>", Wrapper=Wrapper)
+    assert result == "<div><p>content</p></div>"
+
+
+def test_component_children_pre_joined():
+    from fragments.types import Children
+
+    def Wrapper(children: Children) -> str:
+        return f"<div>{children}</div>"
+
+    result = render(
+        "<><Wrapper><p>one</p><p>two</p></Wrapper></>",
+        Wrapper=Wrapper,
+    )
+    assert result == "<div><p>one</p><p>two</p></div>"

{python_fragments-0.29 → python_fragments-0.31}/tests/test_grammar.py

@@ -2,6 +2,7 @@ import pytest
 
 from fragments import grammar
 from fragments.ast_nodes import (
+    ASTChildrenSlot,
     ASTComponent,
     ASTComponentArgument,
     ASTComponentName,
@@ -367,6 +368,53 @@ def test_lowercase_not_parsed_as_component():
     assert isinstance(fragment.children[0], ASTHTMLElement)
 
 
+# ---------------------------------------------------------------------------
+# Children slot
+# ---------------------------------------------------------------------------
+
+
+def test_children_slot_parses():
+    source = Source.from_string("<><Children... /></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert _transpiled(fragment) == _transpiled(ASTFragment(-1, -1, [
+        ASTChildrenSlot(-1, -1)
+    ]))
+
+
+def test_children_slot_transpiles_to_children():
+    source = Source.from_string("<><Children... /></>")
+    _, fragment = grammar.expect_fragment(source)
+    fragment.transpile(0)
+    slot = fragment.children[0]
+    assert isinstance(slot, ASTChildrenSlot)
+    assert slot.transpiled_content == "children"
+
+
+def test_children_slot_multiple_in_one_fragment():
+    source = Source.from_string("<><Children... /><Children... /></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert len(fragment.children) == 2
+    assert all(isinstance(child, ASTChildrenSlot) for child in fragment.children)
+
+
+def test_children_slot_not_confused_with_component():
+    source = Source.from_string("<><Children /></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert isinstance(fragment.children[0], ASTComponent)
+
+
+def test_children_slot_inside_element():
+    source = Source.from_string("<><div><Children... /></div></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    element = fragment.children[0]
+    assert isinstance(element, ASTHTMLElement)
+    assert isinstance(element.children[0], ASTChildrenSlot)
+
+
 # ---------------------------------------------------------------------------
 # HTML text
 # ---------------------------------------------------------------------------

{python_fragments-0.29 → python_fragments-0.31}/tests/test_html_elements.py

@@ -22,10 +22,10 @@ def test_className_string_passthrough():
 
 
 def test_el_className_list_attribute():
-    result = el("div", ["content"], False, {"className": ["foo", "bar"]})
+    result = el("div", "content", False, {"className": ["foo", "bar"]})
     assert result == '<div class="foo bar">content</div>'
 
 
 def test_el_className_empty_list():
-    result = el("div", [], True, {"className": []})
+    result = el("div", "", True, {"className": []})
     assert result == '<div class="" />'

{python_fragments-0.29 → python_fragments-0.31}/tests/test_source_map.py

@@ -1,7 +1,7 @@
 from fragments.lsp.file_state import FileState
 from lsprotocol import types
 
-IMPORT_PREFIX = "from fragments.html.elements import el, sequence, comment\n"
+IMPORT_PREFIX = "from fragments.html.elements import el, _sequence, comment\n"
 IMPORT_PREFIX_LEN = len(IMPORT_PREFIX)