Clean up some naming usages and things

10 files changed, 36 insertions, 41 deletions

diff --git a/htmtl/__init__.py b/htmtl/__init__.py
index 4286154..f5708d1 100644
--- a/htmtl/__init__.py
+++ b/htmtl/__init__.py
@@ -1,3 +1,3 @@
 from .htmtl import Htmtl
-from .attribute_parser import AttributeParser
-from .expression_modifier import ExpressionModifier, modifier
\ No newline at end of file
+from .parser import Parser
+from .modifier import Modifier, modifier_name
\ No newline at end of file
diff --git a/htmtl/expression_parser.py b/htmtl/expression_parser.py
index 6d955d9..a99791b 100644
--- a/htmtl/expression_parser.py
+++ b/htmtl/expression_parser.py
@@ -1,12 +1,12 @@
 from typing import Any
-from .expression_modifier import ExpressionModifier
+from .modifier import Modifier
 
 
 class ExpressionParser:
     __data: dict[str, Any]
-    __expression_modifiers: list[type[ExpressionModifier]]
+    __expression_modifiers: list[type[Modifier]]
 
-    def __init__(self, data: dict[str, Any], expression_modifiers: list[type[ExpressionModifier]]) -> None:
+    def __init__(self, data: dict[str, Any], expression_modifiers: list[type[Modifier]]) -> None:
         self.__data = data
         self.__expression_modifiers = expression_modifiers
 
diff --git a/htmtl/htmtl.py b/htmtl/htmtl.py
index a865eaf..8c9a7a7 100644
--- a/htmtl/htmtl.py
+++ b/htmtl/htmtl.py
@@ -1,51 +1,47 @@
 from typing import Any
 from dompa import Dompa
-from .attribute_parser import AttributeParser
-from .attribute_parsers.inner_text import InnerText
-from .attribute_parsers.outer_text import OuterText
-from .expression_modifier import ExpressionModifier
-from .expression_modifiers.truncate import Truncate
+from .parser import Parser
+from .parsers.inner_text import InnerText
+from .parsers.outer_text import OuterText
+from .modifier import Modifier
+from .modifiers.truncate import Truncate
 from .expression_parser import ExpressionParser
 
 
 class Htmtl:
     __dom: Dompa
     __data: dict[str, Any]
-    __attribute_parsers: list[type[AttributeParser]]
-    __expression_modifiers: list[type[ExpressionModifier]]
+    __parsers: list[type[Parser]]
+    __modifiers: list[type[Modifier]]
 
     def __init__(self, template: str, data: dict[str, Any] = None):
         self.__dom = Dompa(template)
         self.__data = data or {}
-        self.__attribute_parsers = self.__default_attribute_parsers()
-        self.__expression_modifiers = self.__default_expression_modifiers()
 
-    @staticmethod
-    def __default_attribute_parsers() -> list[type[AttributeParser]]:
-        return [
+        # set default attribute parsers
+        self.__attribute_parsers = [
             InnerText,
             OuterText,
         ]
 
-    @staticmethod
-    def __default_expression_modifiers() -> list[type[ExpressionModifier]]:
-        return [
+        # set default expression modifiers
+        self.__expression_modifiers = [
             Truncate,
         ]
 
-    def set_attribute_parsers(self, parsers: list[type[AttributeParser]]):
+    def set_parsers(self, parsers: list[type[Parser]]):
         for parser in parsers:
-            if not isinstance(parser, AttributeParser):
-                raise TypeError("Attribute parser must extend the AttributeParser class.")
+            if not isinstance(parser, Parser):
+                raise TypeError("Parser must extend the Parser class.")
 
-        self.__attribute_parsers = parsers
+        self.__parsers = parsers
 
-    def set_expression_modifiers(self, modifiers: list[type[ExpressionModifier]]):
+    def set_modifiers(self, modifiers: list[type[Modifier]]):
         for modifier in modifiers:
-            if not isinstance(modifier, ExpressionModifier):
-                raise NotImplementedError("Modifier must extend the ExpressionModifier class.")
+            if not isinstance(modifier, Modifier):
+                raise NotImplementedError("Modifier must extend the Modifier class.")
 
-        self.__expression_modifiers = modifiers
+        self.__modifiers = modifiers
 
     def __parse(self) -> None:
         expression_parser = ExpressionParser(self.__data, self.__expression_modifiers)
diff --git a/htmtl/expression_modifier.py b/htmtl/modifier.py
index 69d6a86..a771cca 100644
--- a/htmtl/expression_modifier.py
+++ b/htmtl/modifier.py
@@ -2,7 +2,7 @@ from abc import abstractmethod, ABC
 from typing import Any
 
 
-class ExpressionModifier(ABC):
+class Modifier(ABC):
     name: str
 
     @abstractmethod
@@ -10,8 +10,8 @@ class ExpressionModifier(ABC):
         pass
 
 
-def modifier(name: str):
-    def wrapper(cls: type[ExpressionModifier]):
+def modifier_name(name: str):
+    def wrapper(cls: type[Modifier]):
         cls.name = name
 
         return cls
diff --git a/htmtl/expression_modifiers/__init__.py b/htmtl/modifiers/__init__.py
index f200bbd..f200bbd 100644
--- a/htmtl/expression_modifiers/__init__.py
+++ b/htmtl/modifiers/__init__.py
diff --git a/htmtl/expression_modifiers/truncate.py b/htmtl/modifiers/truncate.py
index 41a1bdb..bac2862 100644
--- a/htmtl/expression_modifiers/truncate.py
+++ b/htmtl/modifiers/truncate.py
@@ -1,10 +1,10 @@
 from typing import Any
 
-from ..expression_modifier import ExpressionModifier, modifier
+from ..modifier import Modifier, modifier_name
 
 
-@modifier("truncate")
-class Truncate(ExpressionModifier):
+@modifier_name("truncate")
+class Truncate(Modifier):
     def modify(self, value: Any, opts: list[Any]) -> Any:
         if isinstance(value, str) and len(opts) > 0:
             if all([x in "1234567890" for x in opts[0]]):
diff --git a/htmtl/attribute_parser.py b/htmtl/parser.py
index 7511c8e..a91de0a 100644
--- a/htmtl/attribute_parser.py
+++ b/htmtl/parser.py
@@ -1,11 +1,10 @@
 from abc import ABC, abstractmethod
 from typing import Any, Optional
 from dompa.nodes import Node
+from .expression_parser import ExpressionParser
 
-from htmtl.expression_parser import ExpressionParser
 
-
-class AttributeParser(ABC):
+class Parser(ABC):
     __data: dict[str, Any]
     __expression_parser: ExpressionParser
 
diff --git a/htmtl/attribute_parsers/__init__.py b/htmtl/parsers/__init__.py
index 4ad8185..4ad8185 100644
--- a/htmtl/attribute_parsers/__init__.py
+++ b/htmtl/parsers/__init__.py
diff --git a/htmtl/attribute_parsers/inner_text.py b/htmtl/parsers/inner_text.py
index 75ad01e..52fc0b4 100644
--- a/htmtl/attribute_parsers/inner_text.py
+++ b/htmtl/parsers/inner_text.py
@@ -1,10 +1,10 @@
 from typing import Optional
 
 from dompa.nodes import Node, TextNode
-from ..attribute_parser import AttributeParser
+from ..parser import Parser
 
 
-class InnerText(AttributeParser):
+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"]))]
diff --git a/htmtl/attribute_parsers/outer_text.py b/htmtl/parsers/outer_text.py
index 8e9bead..78b0fce 100644
--- a/htmtl/attribute_parsers/outer_text.py
+++ b/htmtl/parsers/outer_text.py
@@ -1,10 +1,10 @@
 from typing import Optional
 
 from dompa.nodes import Node, TextNode
-from ..attribute_parser import AttributeParser
+from ..parser import Parser
 
 
-class OuterText(AttributeParser):
+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"]))