From 4a3208b8c16bf9b3857163f588e68b3ae505cd4b Mon Sep 17 00:00:00 2001
From: Asko Nõmm <asko@nmm.ee>
Date: Thu, 9 Jan 2025 21:43:58 +0200
Subject: Getting there

---
 htmtl/expression_parser.py     |  7 ++++++-
 htmtl/htmtl.py                 | 22 ++++++++++++++--------
 htmtl/parser.py                | 12 +++++++++---
 htmtl/parsers/generic_value.py |  6 +++---
 htmtl/parsers/inner_html.py    |  5 +++--
 htmtl/parsers/inner_partial.py |  6 ++++--
 htmtl/parsers/inner_text.py    |  5 +++--
 htmtl/parsers/iterate.py       | 11 ++++++-----
 htmtl/parsers/outer_html.py    |  6 ++++--
 htmtl/parsers/outer_partial.py |  6 ++++--
 htmtl/parsers/outer_text.py    |  4 +++-
 htmtl/parsers/when.py          |  4 ++--
 htmtl/parsers/when_not.py      |  4 ++--
 13 files changed, 63 insertions(+), 35 deletions(-)

(limited to 'htmtl')

diff --git a/htmtl/expression_parser.py b/htmtl/expression_parser.py
index fc3aa8d..c63b9ec 100644
--- a/htmtl/expression_parser.py
+++ b/htmtl/expression_parser.py
@@ -37,7 +37,8 @@ class ExpressionParser:
 
             if interp_start is not None and interp_end is not None:
                 interp = expression[interp_start:interp_end]
-                parsed_expression = parsed_expression.replace(interp, self.__parse_interpolation(interp[1:-1]))
+                parsed_interp = self.__parse_interpolation(interp[1:-1])
+                parsed_expression = parsed_expression.replace(interp, parsed_interp)
                 interp_start = None
                 interp_end = None
 
@@ -117,6 +118,10 @@ class ExpressionParser:
         return value
 
     def __var_to_val(self, var: str) -> Any:
+        """
+        Turns a expression var into the value it maps to
+        in the data dictionary.
+        """
         parts = var.split(".")
         value = self.__data
 
diff --git a/htmtl/htmtl.py b/htmtl/htmtl.py
index 6570e11..a47dd2b 100644
--- a/htmtl/htmtl.py
+++ b/htmtl/htmtl.py
@@ -1,6 +1,6 @@
 from typing import Any
 from dompa import Dompa
-from dompa.actions import ToHtml
+from dompa.serializers import ToHtml
 from dompa.nodes import Node
 from .parser import Parser
 from .parsers.generic_value import GenericValue
@@ -29,7 +29,7 @@ class Htmtl:
         self.__data = data or {}
 
         # set default attribute parsers
-        self.__attribute_parsers = [
+        self.__parsers = [
             Iterate,
             InnerText,
             InnerHtml,
@@ -43,7 +43,7 @@ class Htmtl:
         ]
 
         # set default expression modifiers
-        self.__expression_modifiers = [
+        self.__modifiers = [
             Truncate,
         ]
 
@@ -62,18 +62,24 @@ class Htmtl:
         self.__modifiers = modifiers
 
     def __parse(self) -> None:
-        expression_parser = ExpressionParser(self.__data, self.__expression_modifiers)
+        expression_parser = ExpressionParser(self.__data, self.__modifiers)
 
-        for parser in self.__attribute_parsers:
+        for parser in self.__parsers:
             parser_instance = parser(self.__data, expression_parser)
             self.__dom.traverse(parser_instance.traverse)
 
     def to_html(self) -> str:
+        """
+        Conver the template into HTML.
+        """
         self.__parse()
 
-        return self.__dom.action(ToHtml)
+        return self.__dom.serialize(ToHtml)
 
-    def nodes(self) -> list[Node]:
+    def get_nodes(self) -> list[Node]:
+        """
+        Return the node tree representation of the template.
+        """
         self.__parse()
 
-        return self.__dom.get_nodes()
\ No newline at end of file
+        return self.__dom.get_nodes()
diff --git a/htmtl/parser.py b/htmtl/parser.py
index 393a5bd..f87070d 100644
--- a/htmtl/parser.py
+++ b/htmtl/parser.py
@@ -12,12 +12,18 @@ class Parser(ABC):
         self.__data = data
         self.__expression_parser = expression_parser
 
-    def data(self) -> dict[str, Any]:
+    def get_data(self) -> dict[str, Any]:
+        """
+        Return the data dictionary.
+        """
         return self.__data
 
-    def expression(self, expression: str) -> Any:
+    def parse_expression(self, expression: str) -> Any:
+        """
+        Parses a given expression.
+        """
         return self.__expression_parser.parse(expression)
 
     @abstractmethod
     def traverse(self, node: Node) -> Optional[Node]:
-        pass
\ No newline at end of file
+        pass
diff --git a/htmtl/parsers/generic_value.py b/htmtl/parsers/generic_value.py
index 87b0d63..bac9577 100644
--- a/htmtl/parsers/generic_value.py
+++ b/htmtl/parsers/generic_value.py
@@ -9,10 +9,10 @@ class GenericValue(Parser):
 
         for key, val in node.attributes.items():
             if key.startswith(":"):
-                new_attrs[key[1:]] = self.expression(val)
+                new_attrs[key[1:]] = self.parse_expression(val)
             else:
                 new_attrs[key] = val
 
         node.attributes = new_attrs
-        
-        return node
\ No newline at end of file
+
+        return node
diff --git a/htmtl/parsers/inner_html.py b/htmtl/parsers/inner_html.py
index 60e90ca..df5f0f4 100644
--- a/htmtl/parsers/inner_html.py
+++ b/htmtl/parsers/inner_html.py
@@ -9,8 +9,9 @@ from ..parser import Parser
 class InnerHtml(Parser):
     def traverse(self, node: Node) -> Optional[Node]:
         if "inner-html" in node.attributes:
-            child_nodes = Dompa(self.expression(node.attributes["inner-html"])).nodes()
+            exp = self.parse_expression(node.attributes["inner-html"])
+            child_nodes = Dompa(exp).get_nodes()
             node.children = child_nodes
             node.attributes.pop("inner-html")
 
-        return node
\ No newline at end of file
+        return node
diff --git a/htmtl/parsers/inner_partial.py b/htmtl/parsers/inner_partial.py
index 80020aa..e2c0842 100644
--- a/htmtl/parsers/inner_partial.py
+++ b/htmtl/parsers/inner_partial.py
@@ -6,12 +6,14 @@ from dompa.nodes import Node
 from ..parser import Parser
 import htmtl
 
+
 class InnerPartial(Parser):
     def traverse(self, node: Node) -> Optional[Node]:
         if "inner-partial" in node.attributes:
-            template = htmtl.Htmtl(self.expression(node.attributes["inner-partial"]), self.data())
+            exp = self.parse_expression(node.attributes["inner-partial"])
+            template = htmtl.Htmtl(exp, self.get_data())
             child_nodes = Dompa(template.to_html()).get_nodes()
             node.children = child_nodes
             node.attributes.pop("inner-partial")
 
-        return node
\ No newline at end of file
+        return node
diff --git a/htmtl/parsers/inner_text.py b/htmtl/parsers/inner_text.py
index 52fc0b4..c147b12 100644
--- a/htmtl/parsers/inner_text.py
+++ b/htmtl/parsers/inner_text.py
@@ -7,7 +7,8 @@ from ..parser import Parser
 class InnerText(Parser):
     def traverse(self, node: Node) -> Optional[Node]:
         if "inner-text" in node.attributes:
-            node.children = [TextNode(value=self.expression(node.attributes["inner-text"]))]
+            exp = self.parse_expression(node.attributes["inner-text"])
+            node.children = [TextNode(value=exp)]
             node.attributes.pop("inner-text")
 
-        return node
\ No newline at end of file
+        return node
diff --git a/htmtl/parsers/iterate.py b/htmtl/parsers/iterate.py
index a70d026..cc70491 100644
--- a/htmtl/parsers/iterate.py
+++ b/htmtl/parsers/iterate.py
@@ -1,11 +1,12 @@
 from collections.abc import Iterable
 from typing import Optional
 
-from dompa.nodes.actions import ToHtml
+from dompa.nodes.serializers import ToHtml
 from dompa.nodes import Node, FragmentNode
 from ..parser import Parser
 import htmtl
 
+
 class IterateOp:
     var: str
     iter_var_as: Optional[str]
@@ -22,11 +23,11 @@ class Iterate(Parser):
         if "iterate" in node.attributes:
             replacement_nodes = []
             iterate_op = self.__parse_exp(node.attributes["iterate"])
-            collection = self.expression(iterate_op.var)
+            collection = self.parse_expression(iterate_op.var)
             node.attributes.pop("iterate")
 
             if isinstance(collection, Iterable):
-                data = self.data()
+                data = self.get_data()
 
                 for idx, item in enumerate(collection):
                     if iterate_op.iter_var_as:
@@ -35,8 +36,8 @@ class Iterate(Parser):
                     if iterate_op.iter_index_as:
                         data[iterate_op.iter_index_as] = idx
 
-                    template = htmtl.Htmtl(node.action(ToHtml), data)
-                    template_nodes = template.nodes()
+                    template = htmtl.Htmtl(node.serialize(ToHtml), data)
+                    template_nodes = template.get_nodes()
 
                     if len(template_nodes) > 0:
                         replacement_nodes.append(template_nodes[0])
diff --git a/htmtl/parsers/outer_html.py b/htmtl/parsers/outer_html.py
index 72df638..27d2daf 100644
--- a/htmtl/parsers/outer_html.py
+++ b/htmtl/parsers/outer_html.py
@@ -9,6 +9,8 @@ from ..parser import Parser
 class OuterHtml(Parser):
     def traverse(self, node: Node) -> Optional[Node]:
         if "outer-html" in node.attributes:
-            return FragmentNode(children=Dompa(self.expression(node.attributes["outer-html"])).nodes())
+            exp = self.parse_expression(node.attributes["outer-html"])
 
-        return node
\ No newline at end of file
+            return FragmentNode(children=Dompa(exp).get_nodes())
+
+        return node
diff --git a/htmtl/parsers/outer_partial.py b/htmtl/parsers/outer_partial.py
index 69866ad..3e1109a 100644
--- a/htmtl/parsers/outer_partial.py
+++ b/htmtl/parsers/outer_partial.py
@@ -6,12 +6,14 @@ from dompa.nodes import Node, FragmentNode
 from ..parser import Parser
 import htmtl
 
+
 class OuterPartial(Parser):
     def traverse(self, node: Node) -> Optional[Node]:
         if "outer-partial" in node.attributes:
-            template = htmtl.Htmtl(self.expression(node.attributes["outer-partial"]), self.data())
+            exp = self.parse_expression(node.attributes["outer-partial"])
+            template = htmtl.Htmtl(exp, self.get_data())
             replacement_nodes = Dompa(template.to_html()).get_nodes()
 
             return FragmentNode(children=replacement_nodes)
 
-        return node
\ No newline at end of file
+        return node
diff --git a/htmtl/parsers/outer_text.py b/htmtl/parsers/outer_text.py
index 78b0fce..0b21d3a 100644
--- a/htmtl/parsers/outer_text.py
+++ b/htmtl/parsers/outer_text.py
@@ -7,6 +7,8 @@ from ..parser import Parser
 class OuterText(Parser):
     def traverse(self, node: Node) -> Optional[Node]:
         if "outer-text" in node.attributes:
-            return TextNode(value=self.expression(node.attributes["outer-text"]))
+            exp = self.parse_expression(node.attributes["outer-text"])
+
+            return TextNode(value=exp)
 
         return node
diff --git a/htmtl/parsers/when.py b/htmtl/parsers/when.py
index 57a965a..249e5b0 100644
--- a/htmtl/parsers/when.py
+++ b/htmtl/parsers/when.py
@@ -6,9 +6,9 @@ from ..parser import Parser
 class When(Parser):
     def traverse(self, node: Node) -> Optional[Node]:
         if "when" in node.attributes:
-            if not self.expression(node.attributes["when"]):
+            if not self.parse_expression(node.attributes["when"]):
                 return None
 
             node.attributes.pop("when")
 
-        return node
\ No newline at end of file
+        return node
diff --git a/htmtl/parsers/when_not.py b/htmtl/parsers/when_not.py
index 68e3d09..96383b7 100644
--- a/htmtl/parsers/when_not.py
+++ b/htmtl/parsers/when_not.py
@@ -6,9 +6,9 @@ from ..parser import Parser
 class WhenNot(Parser):
     def traverse(self, node: Node) -> Optional[Node]:
         if "when-not" in node.attributes:
-            if self.expression(node.attributes["when-not"]):
+            if self.parse_expression(node.attributes["when-not"]):
                 return None
 
             node.attributes.pop("when-not")
 
-        return node
\ No newline at end of file
+        return node
-- 
cgit v1.2.3