python-fragments 0.10__tar.gz → 0.14__tar.gz

{python_fragments-0.10 → python_fragments-0.14}/PKG-INFO

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

{python_fragments-0.10 → python_fragments-0.14}/fragments/ast_nodes.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass, field
 from typing import Sequence
 
+type ASTHTMLChild = ASTHTMLElement | ASTHTMLComment | ASTHTMLText | ASTInterpolation | ASTComponent | ASTControlNode
+
 
 @dataclass(slots=True)
 class ASTModule:
@@ -29,12 +31,12 @@ class ASTModule:
 
     def map_offset(self, offset: int) -> int | None:
         for owner in self.children:
-            if owner.source_start < offset <= owner.source_end:
+            if owner.source_start <= offset <= owner.source_end:
                 return owner.map_offset(offset)
 
     def unmap_offset(self, offset: int) -> int | None:
         for owner in self.children:
-            if owner.transpiled_start < offset <= owner.transpiled_end:
+            if owner.transpiled_start <= offset <= owner.transpiled_end:
                 return owner.unmap_offset(offset)
 
 
@@ -56,14 +58,14 @@ class ASTPython:
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
-        if self.source_start < offset <= self.source_end:
+        if self.source_start <= offset <= self.source_end:
             specific_offset = offset - self.source_start
             return self.transpiled_start + specific_offset
 
         return None
 
     def unmap_offset(self, offset: int) -> int | None:
-        if self.transpiled_start < offset <= self.transpiled_end:
+        if self.transpiled_start <= offset <= self.transpiled_end:
             specific_offset = offset - self.transpiled_start
             return self.source_start + specific_offset
 
@@ -75,7 +77,7 @@ class ASTFragment:
     source_start: int = field(compare=False)
     source_end: int = field(compare=False)
 
-    children: list["ASTHTMLElement | ASTHTMLComment | ASTHTMLText | ASTInterpolation"]
+    children: list["ASTHTMLChild"]
 
     transpiled_content: str = field(init=False)
     transpiled_start: int = field(init=False)
@@ -96,14 +98,14 @@ class ASTFragment:
 
     def map_offset(self, offset: int) -> int | None:
         for owner in self.children:
-            if owner.source_start < offset <= owner.source_end:
+            if owner.source_start <= offset <= owner.source_end:
                 return owner.map_offset(offset)
 
         return None
 
     def unmap_offset(self, offset: int) -> int | None:
         for owner in self.children:
-            if owner.transpiled_start < offset <= owner.transpiled_end:
+            if owner.transpiled_start <= offset <= owner.transpiled_end:
                 return owner.unmap_offset(offset)
 
         return None
@@ -116,114 +118,229 @@ class ASTHTMLElement:
 
     name: str
     attributes: dict[str, "ASTHTMLAttribute"]
-    if_attribute: "ASTInterpolation | None"
-    for_attribute: "ASTInterpolation | None"
-    children: Sequence["ASTHTMLElement | ASTHTMLComment | ASTHTMLText | ASTInterpolation"]
+    children: Sequence["ASTHTMLChild"]
     one_line: bool
 
     transpiled_content: str = field(init=False)
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __for_template__: str = """sequence([{} for {}])"""
-    __if_template__: str = """{} if {} else ''"""
-    __element_template__: str = """el("{}",[{}],oneline={},{})"""
-    __component_template__: str = """{}([{}],{})"""
+    __element_template__: str = """el("{}",[{}],oneline={},attributes={})"""
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
-
-        if self.for_attribute is not None:
-            transpiled_start += 10
-
-        if self.name[0].capitalize() == self.name[0]:
-            self._transpile_component_call(transpiled_start)
-        else:
-            self._transpile_element_call(transpiled_start)
-
-        if self.if_attribute is not None:
-            self.if_attribute.transpile(self.transpiled_end + 4)
-            self.transpiled_content = self.__if_template__.format(self.transpiled_content, self.if_attribute.transpiled_content)
-            self.transpiled_end = self.if_attribute.transpiled_end + 8
-        elif self.for_attribute is not None:
-            self.for_attribute.transpile(self.transpiled_end + 5)
-            self.transpiled_content = self.__for_template__.format(self.transpiled_content, self.for_attribute.transpiled_content)
-            self.transpiled_end = self.for_attribute.transpiled_end + 2
-
-    def _transpile_element_call(self, start: int) -> None:
-        transpiled_start = start + len(self.name) + 7
+        transpiled_start = transpiled_start + len(self.name) + 7
         for child in self.children:
             child.transpile(transpiled_start)
             transpiled_start = child.transpiled_end + 1
-        transpiled_start -= 1
+        if self.children:
+            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 + 1
-
+        transpiled_start += 10 + 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())
+        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_end = start + len(self.transpiled_content)
+        self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
+
+    def map_offset(self, offset: int) -> int | None:
+        for attribute in self.attributes.values():
+            if attribute.source_start <= offset <= attribute.source_end:
+                return attribute.map_offset(offset)
+
+        for child in self.children:
+            if child.source_start <= offset <= child.source_end:
+                return child.map_offset(offset)
+
+        return None
+
+    def unmap_offset(self, offset: int) -> int | None:
+        for attribute in self.attributes.values():
+            if attribute.transpiled_start <= offset <= attribute.transpiled_end:
+                return attribute.unmap_offset(offset)
 
-    def _transpile_component_call(self, start: int) -> None:
-        transpiled_start = start + len(self.name) + 2
+        for child in self.children:
+            if child.transpiled_start <= offset <= child.transpiled_end:
+                return child.unmap_offset(offset)
+
+        return None
+
+
+@dataclass(slots=True)
+class ASTControlNode[T: (ASTHTMLElement, ASTComponent)]:
+    source_start: int = field(compare=False)
+    source_end: int = field(compare=False)
+
+    if_interpolation: "ASTInterpolation | None"
+    for_interpolation: "ASTInterpolation | None"
+    child: T
+
+    transpiled_content: str = field(init=False)
+    transpiled_start: int = field(init=False)
+    transpiled_end: int = field(init=False)
+
+    __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.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.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)
+
+    def map_offset(self, offset: int) -> int | None:
+        if self.if_interpolation is not None and self.if_interpolation.source_start <= offset <= self.if_interpolation.source_end:
+            return self.if_interpolation.map_offset(offset)
+
+        if self.for_interpolation is not None and self.for_interpolation.source_start <= offset <= self.for_interpolation.source_end:
+            return self.for_interpolation.map_offset(offset)
+
+        if self.child.source_start <= offset <= self.child.source_end:
+            return self.child.map_offset(offset)
+
+        return None
+
+    def unmap_offset(self, offset: int) -> int | None:
+        if self.child.transpiled_start <= offset <= self.child.transpiled_end:
+            return self.child.unmap_offset(offset)
+
+        if self.if_interpolation is not None and self.if_interpolation.transpiled_start <= offset <= self.if_interpolation.transpiled_end:
+            return self.if_interpolation.unmap_offset(offset)
+
+        if self.for_interpolation is not None and self.for_interpolation.transpiled_start <= offset <= self.for_interpolation.transpiled_end:
+            return self.for_interpolation.unmap_offset(offset)
+
+        return None
+
+    @classmethod
+    def wrap_child(
+        cls,
+        child: T,
+        if_interpolation: "ASTInterpolation | None",
+        for_interpolation: "ASTInterpolation | None",
+    ) -> "ASTControlNode[T] | T":
+        """If the child needs a control node, wrap it."""
+        if if_interpolation is None and for_interpolation is None:
+            return child
+
+        return ASTControlNode(child.source_start, child.source_end, if_interpolation, for_interpolation, child)
+
+
+@dataclass(slots=True)
+class ASTComponent:
+    source_start: int = field(compare=False)
+    source_end: int = field(compare=False)
+
+    name: str
+    arguments: dict[str, "ASTComponentArgument"]
+    children: Sequence["ASTHTMLChild"]
+
+    transpiled_content: str = field(init=False)
+    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
+        transpiled_start = transpiled_start + len(self.name) + 2
         for child in self.children:
             child.transpile(transpiled_start)
             transpiled_start = child.transpiled_end + 1
-        transpiled_start -= 1
+        if self.children:
+            transpiled_start -= 1
         children = ",".join(child.transpiled_content for child in self.children)
 
-        if len(self.attributes) == 0:
-            self.transpiled_content = self.__component_template__.format(self.name, children, "")
-            self.transpiled_end = start + len(self.transpiled_content)
+        if len(self.arguments) == 0:
+            self.transpiled_content = self.__template__.format(self.name, children, "")
+            self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
             return
 
         transpiled_start += 2
-        for attribute in self.attributes.values():
+        for attribute in self.arguments.values():
             attribute.transpile(transpiled_start)
             transpiled_start = attribute.transpiled_end + 1
 
-        attributes = ",".join(attribute.transpiled_content for attribute in self.attributes.values())
-        self.transpiled_content = self.__component_template__.format(self.name, children, attributes)
-        self.transpiled_end = start + len(self.transpiled_content)
+        attributes = ",".join(attribute.transpiled_content for attribute in self.arguments.values())
+        self.transpiled_content = self.__template__.format(self.name, children, attributes)
+        self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
-        for attribute in self.attributes.values():
-            if attribute.source_start < offset <= attribute.source_end:
+        for attribute in self.arguments.values():
+            if attribute.source_start <= offset <= attribute.source_end:
                 return attribute.map_offset(offset)
 
         for child in self.children:
-            if child.source_start < offset <= child.source_end:
+            if child.source_start <= offset <= child.source_end:
                 return child.map_offset(offset)
 
-        if self.if_attribute is not None and self.if_attribute.source_start < offset <= self.if_attribute.source_end:
-            return self.if_attribute.map_offset(offset)
-
-        if self.for_attribute is not None and self.for_attribute.source_start < offset <= self.for_attribute.source_end:
-            return self.for_attribute.map_offset(offset)
-
         return None
 
     def unmap_offset(self, offset: int) -> int | None:
-        for attribute in self.attributes.values():
-            if attribute.transpiled_start < offset <= attribute.transpiled_end:
+        for attribute in self.arguments.values():
+            if attribute.transpiled_start <= offset <= attribute.transpiled_end:
                 return attribute.unmap_offset(offset)
 
         for child in self.children:
-            if child.transpiled_start < offset <= child.transpiled_end:
+            if child.transpiled_start <= offset <= child.transpiled_end:
                 return child.unmap_offset(offset)
 
-        if self.if_attribute is not None and self.if_attribute.transpiled_start < offset <= self.if_attribute.transpiled_end:
-            return self.if_attribute.unmap_offset(offset)
+        return None
+
 
-        if self.for_attribute is not None and self.for_attribute.transpiled_start < offset <= self.for_attribute.transpiled_end:
-            return self.for_attribute.unmap_offset(offset)
+@dataclass(slots=True)
+class ASTComponentArgument:
+    source_start: int = field(compare=False)
+    source_end: int = field(compare=False)
+
+    name: str
+    string_literal: str | None
+    interpolation: "ASTInterpolation | None"
+
+    transpiled_content: str = field(init=False)
+    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
+
+        if self.string_literal is not None:
+            self.transpiled_content = self.__template__.format(self.name, self.string_literal)
+            self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
+            return
+
+        assert self.interpolation is not None
+        self.interpolation.transpile(self.transpiled_start + len(self.name) + 1)
+        self.transpiled_content = self.__template__.format(self.name, self.interpolation.transpiled_content)
+        self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
+
+    def map_offset(self, offset: int) -> int | None:
+        if self.interpolation is None:
+            return None
+
+        if self.interpolation.source_start <= offset <= self.interpolation.source_end:
+            return self.interpolation.map_offset(offset)
+
+        return None
+
+    def unmap_offset(self, offset: int) -> int | None:
+        if self.interpolation is None:
+            return None
+
+        if self.interpolation.transpiled_start <= offset <= self.interpolation.transpiled_end:
+            return self.interpolation.unmap_offset(offset)
 
         return None
 
@@ -259,34 +376,37 @@ class ASTHTMLAttribute:
     source_end: int = field(compare=False)
 
     name: str
-    value: str | None
+    string_literal: str | None
     interpolation: "ASTInterpolation | None"
 
     transpiled_content: str = field(init=False)
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __value_template__: str = '{}="{}"'
-    __interpolation_template__: str = "{}={}"
+    __template__: str = '"{}":{}'
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
 
-        if self.value is not None:
-            self.transpiled_content = self.__value_template__.format(self.name, self.value)
+        if self.string_literal is not None:
+            self.transpiled_content = self.__template__.format(self.name, self.string_literal)
             self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
             return
 
-        assert self.interpolation is not None
-        self.interpolation.transpile(self.transpiled_start + len(self.name) + 1)
-        self.transpiled_content = self.__interpolation_template__.format(self.name, self.interpolation.transpiled_content)
+        if self.interpolation is None:
+            self.transpiled_content = self.__template__.format(self.name, "None")
+            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.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
         if self.interpolation is None:
             return None
 
-        if self.interpolation.source_start < offset <= self.interpolation.source_end:
+        if self.interpolation.source_start <= offset <= self.interpolation.source_end:
             return self.interpolation.map_offset(offset)
 
         return None
@@ -295,7 +415,7 @@ class ASTHTMLAttribute:
         if self.interpolation is None:
             return None
 
-        if self.interpolation.transpiled_start < offset <= self.interpolation.transpiled_end:
+        if self.interpolation.transpiled_start <= offset <= self.interpolation.transpiled_end:
             return self.interpolation.unmap_offset(offset)
 
         return None
@@ -344,14 +464,14 @@ class ASTInterpolation:
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
-        if self.source_start + 2 + self.leading_whitespace < offset <= self.source_end - 2 - self.trailing_whitespace:
+        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
             return self.transpiled_start + specific_offset
 
         return None
 
     def unmap_offset(self, offset: int) -> int | None:
-        if self.transpiled_start < offset <= self.transpiled_end:
+        if self.transpiled_start <= offset <= self.transpiled_end:
             specific_offset = offset - self.transpiled_start
             return self.source_start + specific_offset + 2 + self.leading_whitespace
 

python_fragments-0.14/fragments/cli.py

@@ -0,0 +1,44 @@
+import argparse
+
+from fragments import grammar, transpiler
+from fragments.source import Source
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser("fragments", description="Fragments transpilation CLI tool")
+    command_parser = parser.add_subparsers(required=True)
+    transpile_parser = command_parser.add_parser("transpile")
+    transpile_parser.add_argument("--input", type=str, required=True)
+    transpile_parser.set_defaults(func=transpile)
+    ast_parser = command_parser.add_parser("ast")
+    ast_parser.add_argument("--input", type=str, required=True)
+    ast_parser.set_defaults(func=ast)
+    return parser.parse_args()
+
+
+def transpile(args: argparse.Namespace) -> None:
+    """Transpile the specified file."""
+    with open(args.input, "r") as f:
+        source = f.read()
+    print(transpiler.transpile(source))
+
+
+def ast(args: argparse.Namespace) -> None:
+    """Print the AST of the specified file."""
+    with open(args.input, "r") as f:
+        source_string = f.read()
+
+    source = Source.from_string(source_string)
+    _, module_ast = grammar.expect_module(source)
+    module_ast.transpile()
+    print(module_ast)
+
+
+def main():
+    args = parse_args()
+    assert hasattr(args, "func")
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()