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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fragments
-Version: 0.29
+Version: 0.32
 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.32}/fragments/ast_nodes.py

@@ -1,7 +1,10 @@
 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
+
+IMPORT_PREFIX = "from fragments.html.elements import attribute_to_string, comment\n"
+IMPORT_PREFIX_LEN = len(IMPORT_PREFIX)
 
 
 @dataclass(slots=True)
@@ -15,18 +18,17 @@ 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 = "{}\n{}"
 
     def transpile(self, transpiled_start: int = 0) -> None:
         """Build transpiled outputs for the module."""
         self.transpiled_start = transpiled_start
-        transpiled_start += len(self.__template__) - 2
+        self.transpiled_content = IMPORT_PREFIX
+
         for child in self.children:
-            child.transpile(transpiled_start)
-            transpiled_start = child.transpiled_end
+            child.transpile(self.transpiled_start + len(self.transpiled_content))
+            self.transpiled_content += child.transpiled_content
 
-        children: str = "".join(child.transpiled_content for child in self.children)
-        self.transpiled_content = self.__template__.format(children)
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -83,18 +85,18 @@ 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:
-            transpiled_start -= 1
+        self.transpiled_content = '""'
 
-        self.transpiled_content = self.__template__.format(",".join(child.transpiled_content for child in self.children))
+        for child in self.children:
+            self.transpiled_content += "+"
+            if isinstance(child, ASTInterpolation):
+                self.transpiled_content += "str("
+            child.transpile(self.transpiled_start + len(self.transpiled_content))
+            self.transpiled_content += child.transpiled_content
+            if isinstance(child, ASTInterpolation):
+                self.transpiled_content += ")"
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -126,26 +128,32 @@ class ASTHTMLElement:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __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
-        for child in self.children:
-            child.transpile(transpiled_start)
-            transpiled_start = child.transpiled_end + 1
-        if len(self.children) > 0:
-            transpiled_start -= 1
-        children = ",".join(child.transpiled_content for child in self.children)
-        oneline_offset = len(str(self.one_line))
-        transpiled_start += 10 + oneline_offset + 12 + 1  # ],oneline= + oneline + ,attributes= + {
+        self.transpiled_content = f'f"<{self.name}'
+
         for attribute in self.attributes.values():
-            attribute.transpile(transpiled_start)
-            transpiled_start = attribute.transpiled_end + 1
-        transpiled_start -= 1
+            self.transpiled_content += " "
+            attribute.transpile(self.transpiled_start + len(self.transpiled_content))
+            self.transpiled_content += attribute.transpiled_content
 
-        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)
+        if self.one_line:
+            self.transpiled_content += ' />"'
+            self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
+            return
+
+        self.transpiled_content += '>"'
+
+        for child in self.children:
+            self.transpiled_content += "+"
+            if isinstance(child, ASTInterpolation):
+                self.transpiled_content += "str("
+            child.transpile(self.transpiled_start + len(self.transpiled_content))
+            self.transpiled_content += child.transpiled_content
+            if isinstance(child, ASTInterpolation):
+                self.transpiled_content += ")"
+
+        self.transpiled_content += f'+"</{self.name}>"'
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -184,18 +192,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 = "''.join(str({}) 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.for_interpolation.transpile(self.child.transpiled_end + 5)  # child +  for
+            self.child.transpile(transpiled_start + 12)  # ''.join(str(
+            self.for_interpolation.transpile(self.child.transpiled_end + 6)  # 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,31 +258,24 @@ 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
+        self.transpiled_content = self.name.transpiled_content + '(""'
+
         for child in self.children:
-            child.transpile(transpiled_start)
-            transpiled_start = child.transpiled_end + 1
-        if self.children:
-            transpiled_start -= 1
-        children = ",".join(child.transpiled_content for child in self.children)
-
-        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
+            child.transpile(self.transpiled_start + len(self.transpiled_content))
+            self.transpiled_content += "+" + child.transpiled_content
 
-        transpiled_start += 2
-        for attribute in self.arguments.values():
-            attribute.transpile(transpiled_start)
-            transpiled_start = attribute.transpiled_end + 1
+        self.transpiled_content += ","
 
-        attributes = ",".join(attribute.transpiled_content for attribute in self.arguments.values())
-        self.transpiled_content = self.__template__.format(self.name.transpiled_content, children, attributes)
+        for argument in self.arguments.values():
+            argument.transpile(self.transpiled_start + len(self.transpiled_content))
+            self.transpiled_content += argument.transpiled_content + ","
+
+        self.transpiled_content += ")"
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -452,24 +453,23 @@ class ASTHTMLAttribute:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __template__: str = '"{}":{}'
-
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
+        self.transpiled_content = "{" + f"attribute_to_string('{self.name}',"
 
         if self.string_literal is not None:
-            escaped_literal = self.string_literal.replace("\n", "\\n").replace("\t", "\\t").replace("\r", "\\r").replace('"', '"')
-            self.transpiled_content = self.__template__.format(self.name, escaped_literal)
+            escaped_literal = self.string_literal.replace("\n", "\\n").replace("\t", "\\t").replace("\r", "\\r")
+            self.transpiled_content += escaped_literal + ")}"
             self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
             return
 
         if self.interpolation is None:
-            self.transpiled_content = self.__template__.format(self.name, "None")
+            self.transpiled_content = f'"{self.name}"'
             self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
             return
 
-        self.interpolation.transpile(self.transpiled_start + 1 + len(self.name) + 2)  # " + name + ":
-        self.transpiled_content = self.__template__.format(self.name, self.interpolation.transpiled_content)
+        self.interpolation.transpile(self.transpiled_start + len(self.transpiled_content))
+        self.transpiled_content += self.interpolation.transpiled_content + ")}"
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -535,7 +535,7 @@ class ASTInterpolation:
 
     def map_offset(self, offset: int) -> int | None:
         if self.source_start + 2 + self.leading_whitespace <= offset <= self.source_end - 2 - self.trailing_whitespace:
-            specific_offset = offset - self.source_start - 2 - self.leading_whitespace
+            specific_offset = offset - (self.source_start + self.leading_whitespace + 2)
             return self.transpiled_start + specific_offset
 
         return None
@@ -546,3 +546,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.32}/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.32/fragments/html/elements.py

@@ -0,0 +1,47 @@
+import json
+from typing import Any
+import html
+
+
+def comment(content: str) -> str:
+    return f"<!-- {content} -->"
+
+
+def attribute_to_string(name: str, value: Any) -> str:
+    if value is None:
+        return name
+
+    if isinstance(value, tuple):
+        value = list(value)
+
+    if name == "className":
+        return className_to_string(value)
+
+    if name == "style":
+        return style_to_string(value)
+
+    if isinstance(value, dict) or isinstance(value, list):
+        value = html.escape(json.dumps(value))
+
+    if isinstance(value, bool):
+        value = str(value).lower()
+
+    return f'{name}="{value}"'
+
+
+def className_to_string(contents: list[str] | str) -> str:
+    if isinstance(contents, list):
+        inner = " ".join(contents)
+    else:
+        inner = contents
+
+    return f'class="{inner}"'
+
+
+def style_to_string(style: dict[str, str] | str) -> str:
+    if isinstance(style, dict):
+        inner = ";".join(": ".join(pair) for pair in style.items())
+    else:
+        inner = style
+
+    return f'style="{inner}"'

{python_fragments-0.29 → python_fragments-0.32}/fragments/lsp/client_message_handlers/hover.py

@@ -1,3 +1,4 @@
+import sys
 from lsprotocol import types
 from lsprotocol.types import REQUESTS, NOTIFICATIONS
 from typing import cast

python_fragments-0.32/fragments/types.py

@@ -0,0 +1 @@
+type Children = str

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-fragments"
-version = "0.29"
+version = "0.32"
 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.32}/python_fragments.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fragments
-Version: 0.29
+Version: 0.32
 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.32}/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.32/tests/test_end_to_end.py

@@ -0,0 +1,183 @@
+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>"
+
+
+# ---------------------------------------------------------------------------
+# Special attributes — className and style
+# ---------------------------------------------------------------------------
+
+
+def test_interpolated_classname_list():
+    result = render("<><div className={{ classes }}>text</div></>", classes=["foo", "bar"])
+    assert result == '<div class="foo bar">text</div>'
+
+
+def test_interpolated_classname_string():
+    result = render("<><div className={{ classes }}>text</div></>", classes="foo bar")
+    assert result == '<div class="foo bar">text</div>'
+
+
+def test_interpolated_style_dict():
+    result = render("<><div style={{ styles }}>text</div></>", styles={"color": "red", "font-size": "12px"})
+    assert result == '<div style="color: red;font-size: 12px">text</div>'
+
+
+def test_interpolated_style_string():
+    result = render("<><div style={{ styles }}>text</div></>", styles="color: red")
+    assert result == '<div style="color: red">text</div>'

{python_fragments-0.29 → python_fragments-0.32}/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.32}/tests/test_html_elements.py

@@ -1,4 +1,4 @@
-from fragments.html.elements import el, className_to_string
+from fragments.html.elements import className_to_string
 
 
 def test_className_list_joined_with_spaces():
@@ -19,13 +19,3 @@ def test_className_single_item_list():
 def test_className_string_passthrough():
     result = className_to_string("already-a-string")
     assert result == 'class="already-a-string"'
-
-
-def test_el_className_list_attribute():
-    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": []})
-    assert result == '<div class="" />'

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

@@ -1,8 +1,6 @@
 from fragments.lsp.file_state import FileState
 from lsprotocol import types
-
-IMPORT_PREFIX = "from fragments.html.elements import el, sequence, comment\n"
-IMPORT_PREFIX_LEN = len(IMPORT_PREFIX)
+from fragments.ast_nodes import IMPORT_PREFIX_LEN
 
 
 def make_state(source_str: str) -> FileState:
@@ -60,19 +58,22 @@ def test_no_fragments_position_mapping():
 
 
 def test_interpolation_is_mappable():
-    source = "<>\n    <p>{{ title }}</p>\n</>"
+    source = "<>\n    <p>{{ title in titles }}</p>\n</>"
     state = make_state(source)
     interp_start = source.index("{{")
     # expression 'title' starts after '{{ ' (2 + 1 space)
     expr_start = interp_start + 3
-    expr = "title"
+    expr = "title in titles"
 
     # Characters of the expression are mappable (first char excluded by exclusive-start).
     for k in range(1, len(expr)):
         t = state.ast_module.map_offset(expr_start + k)
         assert t is not None, f"offset {expr_start + k} should be mappable"
+        assert state.ast_module.map_offset(expr_start + k - 1) == t - 1
         assert state.transpiled[t] == expr[k]
 
+    # Characters in the white space after an expression are not mappable
+
     # Round-trip
     for k in range(1, len(expr)):
         t = state.ast_module.map_offset(expr_start + k)

python_fragments-0.29/fragments/html/elements.py

@@ -1,73 +0,0 @@
-import json
-from typing import Any
-from fragments.types import Children
-import html
-
-
-def sequence(children: Children) -> str:
-    return "".join(str(child) for child in children)
-
-
-def el(
-    name: str,
-    children: Children,
-    oneline: bool,
-    attributes: dict[str, Any],
-) -> str:
-    tag_contents = [
-        name,
-        className_to_string(attributes.pop("className")) if "className" in attributes else None,
-        style_to_string(attributes.pop("style")) if "style" in attributes else None,
-        attributes_to_string(attributes) if attributes else None,
-    ]
-    tag_contents = [item for item in tag_contents if item is not None]
-    tag_contents_string = " ".join(tag_contents)
-
-    if oneline:
-        return f"""<{tag_contents_string} />"""
-
-    children_string = sequence(children)
-
-    return f"""<{tag_contents_string}>{children_string}</{name}>"""
-
-
-def comment(content: str) -> str:
-    return f"<!-- {content} -->"
-
-
-def attributes_to_string(attributes: dict[str, Any]) -> str:
-    return " ".join(attribute_to_string(name, value) for name, value in attributes.items())
-
-
-def attribute_to_string(name: str, value: Any) -> str:
-    if value is None:
-        return name
-
-    if isinstance(value, tuple):
-        value = list(value)
-
-    if isinstance(value, dict) or isinstance(value, list):
-        value = html.escape(json.dumps(value))
-
-    if isinstance(value, bool):
-        value = str(value).lower()
-
-    return f'{name}="{value}"'
-
-
-def className_to_string(contents: list[str] | str) -> str:
-    if isinstance(contents, list):
-        inner = " ".join(contents)
-    else:
-        inner = contents
-
-    return f'class="{inner}"'
-
-
-def style_to_string(style: dict[str, str] | str) -> str:
-    if isinstance(style, dict):
-        inner = ";".join(": ".join(pair) for pair in style.items())
-    else:
-        inner = style
-
-    return f'style="{inner}"'

python_fragments-0.29/fragments/types.py

@@ -1,9 +0,0 @@
-from typing import Protocol
-
-
-class Stringable(Protocol):
-    def __str__(self) -> str: ...
-
-
-type Child = str | Stringable
-type Children = list[Child]