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

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

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

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

@@ -3,6 +3,9 @@ from typing import Sequence
 
 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)
 class ASTModule:
@@ -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:
@@ -85,13 +87,16 @@ class ASTFragment:
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
-        for child in self.children:
-            child.transpile(transpiled_start)
-            transpiled_start = child.transpiled_end + 1
-        if self.children:
-            transpiled_start -= 1
+        self.transpiled_content = '""'
 
-        self.transpiled_content = "+".join(child.transpiled_content for child in self.children) if self.children else '""'
+        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:
@@ -123,28 +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) + 6  # el("name",
-        for child in self.children:
-            child.transpile(transpiled_start)
-            transpiled_start = child.transpiled_end + 1
-        if self.children:
-            transpiled_start -= 1
-        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 += 9 + 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
+
+        if self.one_line:
+            self.transpiled_content += ' />"'
+            self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
+            return
 
-        attributes = "{" + ",".join(attribute.transpiled_content for attribute in self.attributes.values()) + "}"
-        self.transpiled_content = self.__element_template__.format(self.name, children_expr, self.one_line, attributes)
+        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:
@@ -183,14 +192,14 @@ class ASTControlNode[T: (ASTHTMLElement, ASTComponent)]:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __for_template__: str = "_sequence([{} for {}])"
+    __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 + 11)  # _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 + 1)  # ( before child
@@ -254,28 +263,19 @@ class ASTComponent:
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
         self.name.transpile(self.transpiled_start)
-        transpiled_start = self.name.transpiled_end + 1  # (
+        self.transpiled_content = self.name.transpiled_content + '(""'
+
         for child in self.children:
-            child.transpile(transpiled_start)
-            transpiled_start = child.transpiled_end + 1  # + between children
-        if self.children:
-            transpiled_start -= 1
-        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
+            child.transpile(self.transpiled_start + len(self.transpiled_content))
+            self.transpiled_content += "+" + child.transpiled_content
 
-        transpiled_start += 1  # , before arguments
-        for attribute in self.arguments.values():
-            attribute.transpile(transpiled_start)
-            transpiled_start = attribute.transpiled_end + 1
+        self.transpiled_content += ","
+
+        for argument in self.arguments.values():
+            argument.transpile(self.transpiled_start + len(self.transpiled_content))
+            self.transpiled_content += argument.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)
+        self.transpiled_content += ")"
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -453,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:
@@ -536,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

python_fragments-0.33/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 ""
+
+    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.31 → python_fragments-0.33}/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.33/fragments/types.py

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

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

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

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

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

{python_fragments-0.31 → python_fragments-0.33}/tests/test_end_to_end.py

@@ -34,7 +34,7 @@ def test_self_closing_element():
 
 
 def test_empty_fragment():
-    assert render('<></>') == ""
+    assert render("<></>") == ""
 
 
 # ---------------------------------------------------------------------------
@@ -131,7 +131,7 @@ def test_component_no_children():
     def Badge(children: str, label: str) -> str:
         return f"<span>{label}</span>"
 
-    result = render("<><Badge label=\"hi\" /></>", Badge=Badge)
+    result = render('<><Badge label="hi" /></>', Badge=Badge)
     assert result == "<span>hi</span>"
 
 
@@ -156,3 +156,66 @@ def test_component_children_pre_joined():
         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>'
+
+
+# ---------------------------------------------------------------------------
+# Boolean attributes
+# ---------------------------------------------------------------------------
+
+
+def test_bare_boolean_attribute():
+    assert render("<><input disabled /></>") == "<input disabled />"
+
+
+def test_bare_boolean_attribute_with_regular_attribute():
+    result = render('<><input type="checkbox" checked /></>')
+    assert result == '<input type="checkbox" checked />'
+
+
+def test_multiple_bare_boolean_attributes():
+    assert render("<><input disabled required /></>") == "<input disabled required />"
+
+
+def test_boolean_attribute_none_value():
+    assert render("<><input disabled={{ None }} /></>") == "<input  />"
+
+
+def test_boolean_attribute_true_value():
+    assert render("<><input disabled={{ True }} /></>") == '<input disabled="true" />'
+
+
+def test_boolean_attribute_false_value():
+    assert render("<><input disabled={{ False }} /></>") == '<input disabled="false" />'
+
+
+def test_boolean_attribute_true_or_none_value():
+    assert render("<><input disabled={{ True or None }} /></>") == '<input disabled="true" />'
+
+
+def test_boolean_attribute_false_or_none_value():
+    assert render("<><input disabled={{ False or None }} /></>") == "<input  />"

{python_fragments-0.31 → python_fragments-0.33}/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.31 → python_fragments-0.33}/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.31/fragments/html/elements.py

@@ -1,71 +0,0 @@
-import json
-from typing import Any
-from fragments.types import Children, Stringable
-import html
-
-
-def _sequence(items: list[str | Stringable]) -> str:
-    return "".join(str(item) for item in items)
-
-
-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} />"""
-
-    return f"""<{tag_contents_string}>{children}</{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.31/fragments/types.py

@@ -1,8 +0,0 @@
-from typing import Protocol
-
-
-class Stringable(Protocol):
-    def __str__(self) -> str: ...
-
-
-type Children = str