Still adjusting node and build context

eadwinCode · eadwinCode · commit 71e188a3f0d9 · 2024-07-23T11:33:51.000+01:00
diff --git a/Makefile b/Makefile
@@ -29,6 +29,9 @@ fmt format:clean ## Run code formatters
 	ruff format py_html
 	ruff check --fix py_html
 
+ruff-fix: ## Run Ruff fixer
+	ruff check py_html --fix --unsafe-fixes
+
 test:clean ## Run tests
 	pytest
 
diff --git a/bootstrap_exercise.py b/bootstrap_exercise.py
@@ -26,7 +26,7 @@ def template():
     content = BootstrapHTML(
         content=[
             el.Body(
-                content=lambda ctx: el.Fragment(
+                content=el.Fragment(
                     """
                     <div class="container-fluid">
                       <h1>My First Bootstrap Page</h1>
@@ -66,7 +66,7 @@ def template():
                         content=(
                             el.H1(content="Avatars Examples"),
                             el.Div(class_name="mt-2", content=(
-                                BAvatar(text="Foo", class_name="mx-2", size="72px"),
+                                lambda ctx: BAvatar(text="Foo", class_name="mx-2", size="72px"),
                                 BAvatar(icon="people-fill", class_name="mx-2", size="72px"),
                                 BAvatar(
                                     icon="people-fill",
@@ -76,7 +76,7 @@ def template():
                                     variant="primary",
                                     badge_variant="dark"
                                 ),
-                                BAvatar(
+                                lambda ctx: BAvatar(
                                     icon="people-fill",
                                     class_name="mx-2",
                                     size="45px",
@@ -102,7 +102,7 @@ def template():
                                             variant="primary",
                                             badge_variant="dark"
                                         ),
-                                        BAvatar(
+                                        lambda ctx: BAvatar(
                                             icon="people-fill",
                                             size="45px",
                                             badge=BIcon(icon_name="exclamation-circle-fill", variant="warning"),
diff --git a/py_html/contrib/bootstrap/avatar.py b/py_html/contrib/bootstrap/avatar.py
@@ -102,6 +102,7 @@ def resolve_content(self) -> t.Union[Fragment, Element]:
                 content=self.badge,
                 variant=self.badge_variant,
                 position=self.badge_position,
+                style=StyleCSS(font_size=f"calc({self.size} * 0.28)"),
             )
             if self.badge
             else el.Comment(),
@@ -201,8 +202,8 @@ def get_parent_style(self) -> StyleCSS:
             return StyleCSS(padding_left=formular, padding_right=formular)
         return StyleCSS()
 
-    def render_content(self, content: t.Any, ctx: NodeContext) -> str:
-        for node in list(content) if isinstance(content, (list, tuple)) else [content]:
+    def render_content(self, content: Fragment, ctx: NodeContext) -> str:
+        for node in content:
             if isinstance(node.element, BAvatar):
                 if self.size:
                     node.element.size = self.size
diff --git a/py_html/el/base.py b/py_html/el/base.py
@@ -9,27 +9,38 @@
 
 
 class NodeContext:
-    def __init__(
-        self, parent: t.Any, node_element: "Element", node_content: t.Any
-    ) -> None:
+    def __init__(self, node_element: "Element", node_content: t.Any) -> None:
         self.node_element = node_element
-        self.parent_element = parent
         self.node_content = node_content
 
-    def get_content(self, item: t.Any) -> str:
-        if item is None or type(item) is bool:
-            return ""
+    @property
+    def element(self) -> "Element":
+        return self.node_element
 
+    def get_content(self, item: t.Any) -> str:
         if isinstance(item, NodeContext):
+            if isinstance(item.node_element, LazyComponent):
+                item.node_content = item.node_element.resolve_lazy_element()
+
+            if isinstance(item.node_element, Component):
+                item.node_content = item.node_element.resolve_content()
+
             return item.render()
 
-        if isinstance(item, (list, tuple)):
+        if isinstance(item, (list, tuple, Fragment, t.Generator)):
             return "".join(self.get_content(child) for child in item)
 
+        if isinstance(item, Element):
+            node_context = NodeContext(item, item.content)
+            return node_context.render()
+
+        if item is None or type(item) is bool:
+            return ""
+
         return str(item)
 
     def render(self) -> str:
-        inner_html = self.node_element.render_content(self.node_content, self)
+        inner_html = self.node_element.render_content(Fragment(self.node_content), self)
         attrs = self.node_element.render_attributes(self)
 
         return self.node_element.render_tag(attrs, inner_html)
@@ -66,36 +77,32 @@ def render_with_context(
         yield FactoryBuildContext(self.ctx, self.root, element)
 
     def child_node_context(
-        self, element: t.Any, child: t.Any
+        self, child: t.Any
     ) -> t.Union[NodeContext, t.List[NodeContext]]:
         if isinstance(child, Element):
-            if isinstance(child, LazyComponent):
-                child.set_context_data(self)
-
             if isinstance(child, Component):
-                content = self.child_node_context(child, child.resolve_content())
                 child.exports(self)
-            else:
-                content = self.child_node_context(child, child.content)
-            return NodeContext(parent=element, node_element=child, node_content=content)
 
-        if isinstance(child, (list, tuple, Fragment)):
-            return [self.child_node_context(element, child=item) for item in child]
+            content = self.child_node_context(child.content)
+            return NodeContext(node_element=child, node_content=content)
+
+        if isinstance(child, (list, tuple, Fragment, t.Generator)):
+            return [self.child_node_context(child=item) for item in child]
 
         if callable(child):
             with self.render_with_context(child) as factory_ctx:
-                return factory_ctx.build_context(parent=element)
+                return factory_ctx.build_context()
 
         return child
 
     def get_node_context(
         self, element: t.Union["Element", "Fragment"], parent: t.Any
     ) -> t.Union[t.List[NodeContext], NodeContext]:
-        if isinstance(element, (list, tuple, Fragment)):
-            return [self.child_node_context(parent, child=child) for child in element]
+        if isinstance(element, (list, tuple, Fragment, t.Generator)):
+            return [self.child_node_context(child=child) for child in element]
 
-        content = self.child_node_context(parent, element.content)
-        return NodeContext(parent, node_element=element, node_content=content)
+        content = self.child_node_context(element.content)
+        return NodeContext(node_element=element, node_content=content)
 
     def build_context(self, parent=None) -> t.Union[NodeContext, t.List[NodeContext]]:
         return self.get_node_context(self.root, parent=parent)
@@ -332,16 +339,20 @@ def __init__(
 
 
 class Fragment:
-    def __init__(self, *contents: t.Union[Element, t.Any]) -> None:
+    def __init__(self, *contents: t.Union["Fragment", "Element", t.Any]) -> None:
         self.content = list(contents)
 
+    def resolve_content(self, content) -> t.Generator:
+        for item in content:
+            if isinstance(item, Fragment):
+                yield from self.resolve_content(item.content)
+            elif isinstance(item, (list, tuple, t.Generator)):
+                yield from self.resolve_content(item)
+            else:
+                yield item
+
     def __iter__(self):
-        for item in self.content:
-            if isinstance(item, (Fragment, list, tuple)):
-                for y in item:
-                    yield y
-                continue
-            yield item
+        return self.resolve_content(self.content)
 
 
 class LazyComponent(BaseElement):
@@ -353,32 +364,19 @@ class LazyComponent(BaseElement):
 
     def __init__(self, resolver: t.Callable, **attrs) -> None:
         self.tag = "lazy-component"
-
         super(LazyComponent, self).__init__(**attrs)
-
         self._resolver = resolver
-        self._ctx: t.Optional[BuildContext] = None
-
-    def set_context_data(self, ctx: BuildContext) -> None:
-        self._ctx = ctx
-
-    def resolve_lazy_element(
-        self, parent: t.Optional["Element"] = None
-    ) -> t.Union[NodeContext, t.List[NodeContext]]:
-        assert (
-            self._ctx is not None
-        ), "please set_context_data() before resolving element."
 
-        element = self._resolver()
-        return self._ctx.child_node_context(parent, element)
+    def resolve_lazy_element(self) -> t.Union[NodeContext, t.List[NodeContext]]:
+        return self._resolver()
 
     def render_tag(self, attrs: str, inner_html: str) -> str:
         if attrs:
             return f"<div {attrs}>{inner_html}</div>"
         return inner_html
 
     def render_content(self, content: t.Any, ctx: NodeContext) -> t.Any:
-        resolved_content = self.resolve_lazy_element(ctx.parent_element)
+        resolved_content = self.resolve_lazy_element()
         return ctx.get_content(resolved_content)
 
 
diff --git a/py_html/el/elements/semantics.py b/py_html/el/elements/semantics.py
@@ -18,16 +18,18 @@ def __init__(
         self.content = content
 
     def render_content(self, content: t.Any, ctx: NodeContext) -> str:
-        if isinstance(content, (dict, StyleCSS)):
-            ensure_style_css = StyleCSS(**content)
-
-            inner_html = " ".join(
-                (
-                    f"{k} " + "{" + f"{v.render()}" + "}"
-                    for k, v in ensure_style_css.items()
+        for item in content:
+            if isinstance(item, (dict, StyleCSS)):
+                ensure_style_css = StyleCSS(**item)
+
+                inner_html = " ".join(
+                    (
+                        f"{k} " + "{" + f"{v.render()}" + "}"
+                        for k, v in ensure_style_css.items()
+                    )
                 )
-            )
-            return inner_html
+
+                return inner_html
         return ctx.get_content(content)
 
 
