clean: create bozodown module

src/bozodown/bozodown.py

@@ -0,0 +1,65 @@
+
+
+from collections.abc import Callable
+
+from . import default_converters
+
+class Bozodown():
+    
+    def __init__(self):
+        self._converters: dict[str, dict[str, str]] = default_converters.converters.copy()
+        self._text_converter: dict[str, str] = default_converters.text_converter.copy()
+        self._specific_case_namespaces: dict[str, Callable[[object, str, str], str]] = {
+            "bozodown": self._bozodown_render,
+        } 
+
+    def render(self, to_parse: str):
+        content: str = ""
+        while len(to_parse) > 0:
+            text, converter = self._get_first_converter(to_parse)
+            content += self._render_element(text, converter)
+            to_parse = to_parse[len(text):]
+        return content
+
+
+    def _render_element(self, text: str, converter: dict[str, str]) -> str:
+        code: str = converter.get("code")
+        if (code is not None):
+            namespace, id = code.split(":")
+            func = self._specific_case_namespaces[namespace]
+            return func(id, text)
+        start: int = len(converter["from_prefix"])
+        stop: int = len(text) - len(converter.get("from_suffix", ""))
+        return f"{converter['to_prefix']}{text[start:stop]}{converter['to_suffix']}"
+
+    def _bozodown_render(self, id: str, text: str) -> str:
+        if (id == "list"):
+            print("error: list not supported")
+            return ""
+        if (id == "block"):
+            style, to_parse = text[5:-5].split("---")
+            style = style.replace("\n", "")
+            content: str = self.render(to_parse)
+            return f"<div style='{style}'>{content}</div>"
+    
+    def _get_first_converter(self, text: str) -> tuple[str, dict] | None:
+        first_converter_found: dict[str, str] | None = None
+        start: int | None = None
+        for converter in self._converters.values():
+            matching_patern_pos: str = text.find(converter['from_prefix'])
+            if (matching_patern_pos != -1):
+                if (first_converter_found is None or matching_patern_pos < start):
+                    first_converter_found = converter
+                    start = matching_patern_pos
+        if (first_converter_found is None):
+            return text, self._text_converter
+        if (start != 0):
+            return text[:start], self._text_converter
+        suffix: int = first_converter_found.get("from_suffix", "")
+        prefix: int = first_converter_found['from_prefix']
+        stop: int = text.find(suffix, start + len(prefix))
+        if (stop == -1):
+            print(f"error: '{prefix}' was never finished by a '{suffix}'")
+            return
+        stop += len(suffix)
+        return text[start:stop], first_converter_found