Refactor cgx package to sfc package with better names modules (#122)

Author: berendkleinhaneveld

collagraph/__init__.py

@@ -4,7 +4,7 @@
 from .component import Component  # noqa: F401
 from .renderers import *  # noqa: F403
 from .types import EventLoopType, VNode  # noqa: F401
-from .cgx import importer  # noqa: F401
+from .sfc import importer  # noqa: F401
 
 __version__ = version("collagraph")
 

collagraph/__main__.py

@@ -26,7 +26,7 @@ def available_renderers():
 def init_collagraph(
     renderer_type: str, component_path: Path, state: dict | None = None
 ):
-    component_class, _ = cg.cgx.cgx.load(component_path)
+    component_class, _ = cg.sfc.load(component_path)
     props = reactive(state or {})
 
     if renderer_type == "pygfx":

collagraph/__pyinstaller/hook-collagraph.py

@@ -3,7 +3,8 @@
 
 from PyInstaller.utils.hooks import collect_data_files
 
-from collagraph.cgx.cgx import CGXParser, get_script_ast
+from collagraph.sfc.compiler import get_script_ast
+from collagraph.sfc.parser import CGXParser
 
 
 def hook(hook_api):

collagraph/cgx/__init__.py

@@ -28,7 +28,7 @@ def insert(self, el, anchor=None):
 def remove(self, el):
     if hasattr(el, "model_index"):
         # Only support removal of rows for now
-        row, column = getattr(el, "model_index")
+        row, _column = getattr(el, "model_index")
         if model := el.model():
             index = model.indexFromItem(el)
             row = index.row()

collagraph/cgx/importer.py

@@ -0,0 +1,62 @@
+from collagraph import Component
+
+from .compiler import construct_ast
+
+
+def load(path, namespace=None):
+    """
+    Loads and returns a component from a .cgx file.
+
+    A subclass of Component will be created from the .cgx file
+    where the contents of all tags in the root will be used as
+    the `render` function, except for the contents of the <script>
+    tag, which will be used to provide the body of the component.
+
+    For example:
+
+        <item foo="bar">
+          <item baz="bla"/>
+        </item>
+
+        <script>
+        import collagraph as cg
+
+        class Foo(cg.Component):
+            pass
+        </script>
+
+    """
+    template = path.read_text()
+
+    return load_from_string(template, path, namespace=namespace)
+
+
+def load_from_string(template, path=None, namespace=None):
+    """
+    Load template from a string.
+    Returns tuple of class definition and module namespace.
+    """
+    if path is None:
+        path = "<template>"
+
+    # Construct the AST tree
+    tree, name = construct_ast(path=path, template=template)
+
+    # Compile the tree into a code object (module)
+    code = compile(tree, filename=str(path), mode="exec")
+    # Execute the code as module and pass a dictionary that will capture
+    # the global and local scope of the module
+    if namespace is None:
+        namespace = {}
+    exec(code, namespace)
+
+    # Check that the class definition is an actual subclass of Component
+    component_class = namespace[name]
+    if not issubclass(component_class, Component):
+        raise ValueError(
+            f"The last class defined in {path} is not a subclass of "
+            f"Component: {component_class}"
+        )
+    namespace["__component_class"] = component_class
+    namespace["__component_name"] = name
+    return component_class, namespace

collagraph/renderers/pyside/objects/standarditem.py

@@ -7,11 +7,10 @@
 from os import environ
 from pathlib import Path
 
-from collagraph import Component
-
 # Adjust this setting to disable some runtime checks
 # Defaults to True, except when it is part of an installed application
 CGX_RUNTIME_WARNINGS = not getattr(sys, "frozen", False)
+
 DEBUG = bool(environ.get("CGX_DEBUG", False))
 
 SUFFIX = "cgx"
@@ -29,64 +28,6 @@
 MOUSTACHES = re.compile(r"\{\{.*?\}\}")
 
 
-def load(path):
-    """
-    Loads and returns a component from a CGX file.
-
-    A subclass of Component will be created from the CGX file
-    where the contents of the <template> tag will be used as
-    the `render` function, while the contents of the <script>
-    tag will be used to provide the rest of the functions of
-    the component.
-
-    For example:
-
-        <template>
-          <item foo="bar">
-            <item baz="bla"/>
-          </item>
-        </template
-
-        <script>
-        import collagraph as cg
-
-        class Foo(cg.Component):
-            pass
-        </script>
-
-    """
-    template = path.read_text()
-
-    return load_from_string(template, path)
-
-
-def load_from_string(template, path=None):
-    """
-    Load template from a string
-    """
-    if path is None:
-        path = "<template>"
-
-    # Construct the AST tree
-    tree, name = construct_ast(path=path, template=template)
-
-    # Compile the tree into a code object (module)
-    code = compile(tree, filename=str(path), mode="exec")
-    # Execute the code as module and pass a dictionary that will capture
-    # the global and local scope of the module
-    module_namespace = {}
-    exec(code, module_namespace)
-
-    # Check that the class definition is an actual subclass of Component
-    component_class = module_namespace[name]
-    if not issubclass(component_class, Component):
-        raise ValueError(
-            f"The last class defined in {path} is not a subclass of "
-            f"Component: {component_class}"
-        )
-    return component_class, module_namespace
-
-
 def construct_ast(path, template=None):
     """
     Returns a tuple of the constructed AST tree and name of (enhanced) component class.

collagraph/sfc/__init__.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import sys
+from importlib.abc import Loader, MetaPathFinder
+from importlib.machinery import ModuleSpec
+from pathlib import Path
+from types import ModuleType
+from typing import Sequence
+
+from . import compiler, load
+
+
+class CGXLoader(Loader):
+    """Loader for .cgx files"""
+
+    def __init__(self, sfc_path):
+        """Create loader and store the referenced file"""
+        self.sfc_path = sfc_path
+
+    def create_module(self, spec):
+        # Return None to make use of the standard machinery for creating modules
+        return None
+
+    def exec_module(self, module):
+        """Exec the compiled code, using the given module's __dict__ as namespace
+        in order to instantiate the module"""
+        load(self.sfc_path, namespace=module.__dict__)
+
+
+class CGXPathFinder(MetaPathFinder):
+    """MetaPathFinder for CGX files"""
+
+    def find_spec(
+        self, name: str, path: Sequence[str] | None, target: ModuleType | None = None
+    ) -> ModuleSpec | None:
+        # """Look for a cgx file based on the given name and return a ModuleSpec"""
+        if target is not None:
+            # Target is set when module is being reloaded.
+            # In our case we can just return the existing spec.
+            return target.__spec__
+
+        _package, _, module_name = name.rpartition(".")
+        sfc_file_name = f"{module_name}.{compiler.SUFFIX}"
+        directories = sys.path if path is None else path
+        for directory in directories:
+            sfc_path = Path(directory) / sfc_file_name
+            if sfc_path.exists():
+                spec = ModuleSpec(name, CGXLoader(sfc_path), origin=str(sfc_path))
+                spec.has_location = True
+                return spec
+
+
+# Add cgx path finder at the end of the list of finders
+sys.meta_path.append(CGXPathFinder())

collagraph/cgx/cgx.py collagraph/sfc/compiler.pycollagraph/cgx/cgx.py renamed to collagraph/sfc/compiler.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from html.parser import HTMLParser
+from weakref import ref
+
+
+class TextElement:
+    def __init__(self, content, location=None):
+        self.content = content
+        self.location = location
+
+
+class Comment:
+    def __init__(self, content, location=None):
+        self.content = content
+        self.location = location
+
+
+class Element:
+    """Node that represents an element from a CGX file."""
+
+    def __init__(self, tag: str, attrs: dict, location: tuple[int, int]):
+        self.tag = tag
+        self.attrs = attrs or {}
+        self.location = location
+        self.end: tuple[int, int] | None = None
+        self.data: str | None = None
+        self.children: list[Element | Comment | TextElement] = []
+        self.parent: ref | None = None
+
+    def child_with_tag(self, tag):
+        for child in self.children:
+            if getattr(child, "tag", None) == tag:
+                return child
+
+
+class CGXParser(HTMLParser):
+    """Parser for CGX files.
+
+    Creates a tree of Nodes with all encountered attributes and data.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.root = Element("root", attrs={}, location=(-1, -1))
+        self.stack = [self.root]
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]):
+        # The tag parameter is lower-cased by the HTMLParser.
+        # In order to figure out whether the tag indicates
+        # an imported class, we need the original casing for
+        # the tag.
+        # Using the original start tag, we can figure out where
+        # the tag is located using a lower-cased version. And then
+        # use the index to extract the original casing for the tag.
+        complete_tag = self.get_starttag_text()
+        index = complete_tag.lower().index(tag)
+        original_tag = complete_tag[index : index + len(tag)]
+        node = Element(original_tag, attrs=dict(attrs), location=self.getpos())
+
+        # Cast attributes that have no value to boolean (True)
+        # so that they function like flags
+        for key, value in node.attrs.items():
+            if value is None:
+                node.attrs[key] = True
+
+        # Add item as child to the last on the stack
+        parent = self.stack[-1]
+        parent.children.append(node)
+        node.parent = ref(parent)
+        # Make the new node the last on the stack
+        self.stack.append(node)
+
+    def handle_endtag(self, tag: str):
+        # pop it till popping the same tag in order to
+        # work around unclosed tags?
+        # Pop the stack until  (but not the root!)
+        while len(self.stack) > 1:
+            node = self.stack.pop()
+            node.end = self.getpos()
+            if node.tag.lower() == tag:
+                break
+
+    def handle_data(self, data: str):
+        if data.strip():
+            # Add item as child to the last on the stack
+            self.stack[-1].children.append(
+                TextElement(content=data, location=self.getpos())
+            )
+
+    def handle_comment(self, data: str):
+        if data.strip():
+            # Add item as child to the last on the stack
+            self.stack[-1].children.append(
+                Comment(content=data, location=self.getpos())
+            )