Clean up some naming usages and things

1 files changed, 19 insertions, 23 deletions

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)