lema-basic-web-backend 0.1.0__py3-none-any.whl

basic_web_backend/template/evaluator.py

@@ -0,0 +1,114 @@
+from collections.abc import Mapping
+from html import escape
+
+from ..exceptions import TemplateRenderError, UndefinedVariableError
+from .nodes import TextNode, VariableNode, IfNode, ForNode
+
+_MISSING = object()
+
+def render(nodes, context, autoescape=True, template_name=None):
+    if context is None:
+        context = {}
+    else:
+        context = dict(context)
+
+    return _render_nodes(nodes=nodes, context=context, autoescape=autoescape, template_name=template_name)
+
+def _render_nodes(nodes, context, autoescape, template_name):
+    output_parts = []
+
+    for node in nodes:
+        if isinstance(node, TextNode):
+            output_parts.append(node.content)
+            continue
+
+        if isinstance(node, VariableNode):
+            value = _resolve_variable(path=node.path, context=context)
+
+            rendered_value = str(value)
+            if autoescape:
+                rendered_value = escape(rendered_value, quote=True)
+
+            output_parts.append(rendered_value)
+            continue
+
+        if isinstance(node, IfNode):
+            condition_value = _resolve_variable(path=node.condition, context=context)
+
+            if condition_value:
+                selected_nodes = node.body
+            else:
+                selected_nodes = node.else_body
+
+            rendered_branch = _render_nodes(
+                nodes=selected_nodes,
+                context=context,
+                autoescape=autoescape,
+                template_name=template_name
+            )
+
+            output_parts.append(rendered_branch)
+            continue
+
+        if isinstance(node, ForNode):
+            iterable_value = _resolve_variable(path=node.iterable, context=context)
+
+            try:
+                iterator = iter(iterable_value)
+            except TypeError as error:
+                iterable_name = '.'.join(node.iterable)
+                raise TemplateRenderError(
+                    f"Template value is not iterable: {iterable_name}") from error
+
+            for item in iterator:
+                local_context = dict(context)
+
+                local_context[node.variable_name] = item
+                rendered_item = _render_nodes(
+                    nodes=node.body,
+                    context=local_context,
+                    autoescape=autoescape,
+                    template_name=template_name
+                )
+                output_parts.append(rendered_item)
+            continue
+
+        raise TemplateRenderError(
+            f"Unsupported node type: {type(node).__name__}")
+
+    return ''.join(output_parts)
+
+def _resolve_variable(path, context):
+    variable_name = '.'.join(path)
+
+    if not path:
+        raise UndefinedVariableError(variable_name="")
+
+    first_name = path[0]
+
+    if first_name not in context:
+        raise UndefinedVariableError(variable_name=variable_name)
+
+    value = context[first_name]
+
+    for name in path[1:]:
+        value = _resolve_part(
+            value=value,
+            name=name,
+            variable_name=variable_name
+        )
+
+    return value
+
+def _resolve_part(value, name, variable_name):
+    if isinstance(value, Mapping):
+        if name not in value:
+            raise UndefinedVariableError(variable_name=variable_name)
+        return value[name]
+
+    attribute = getattr(value, name, _MISSING)
+
+    if attribute is _MISSING:
+        raise UndefinedVariableError(variable_name=variable_name)
+
+    return attribute

basic_web_backend/template/lexer.py

@@ -0,0 +1,127 @@
+from dataclasses import dataclass
+from enum import Enum
+
+from ..exceptions import TemplateSyntaxError, TemplateSyntaxError
+
+class TokenType(Enum):
+    TEXT = "TEXT"
+    VARIABLE = "VARIABLE"
+    STATEMENT = "STATEMENT"
+
+@dataclass
+class Token:
+    type: TokenType
+    value: str
+    line: int
+    column: int
+
+OPENING_DELIMITER = {
+    "{{": ("}}", TokenType.VARIABLE, "Unclosed variable expression."),
+    "{%": ("%}", TokenType.STATEMENT, "Unclosed statement block."),
+    "{#": ("#}", None, "Unclosed template comment.")
+}
+
+def tokenize(source, template_name=None):
+    tokens = []
+
+    position = 0
+    line = 1
+    column = 1
+
+    while position < len(source):
+        opening_position, opening = (
+            _find_next_opening(source, position)
+        )
+        if opening is None:
+            remaining_text = source[position:]
+
+            if remaining_text:
+                tokens.append(
+                    Token(
+                        type=TokenType.TEXT,
+                        value=remaining_text,
+                        line=line,
+                        column=column
+                    )
+                )
+            break
+
+        if opening_position > position:
+            text = source[position:opening_position]
+            tokens.append(
+                Token(
+                    type=TokenType.TEXT,
+                    value=text,
+                    line=line,
+                    column=column
+                )
+            )
+            line, column = _advance_position(text, line, column)
+
+            position = opening_position
+
+        token_line = line
+        token_column = column
+
+        closing, token_type, error_message = OPENING_DELIMITER[opening]
+        closing_position = source.find(closing, position + len(opening))
+
+        if closing_position == -1:
+            raise TemplateSyntaxError(
+                message=error_message,
+                template_name=template_name,
+                line=token_line,
+                column=token_column
+            )
+
+        content_start = position + len(opening)
+        content = source[content_start:closing_position]
+
+        end_position = closing_position + len(closing)
+
+        complete_section = source[position:end_position]
+
+        if token_type is not None:
+            tokens.append(
+                Token(
+                    type=token_type,
+                    value=content.strip(),
+                    line=token_line,
+                    column=token_column
+                )
+            )
+
+        line, column = _advance_position(text=complete_section, line=line, column=column)
+        position = end_position
+
+    return tokens
+
+def _find_next_opening(source, start):
+    next_position = None
+    next_opening = None
+
+    for opening in OPENING_DELIMITER:
+        position = source.find(opening, start)
+
+        if position == -1:
+            continue
+
+        if next_position is None or position < next_position:
+            next_position = position
+            next_opening = opening
+
+    return next_position, next_opening
+
+def _advance_position(text, line, column):
+    newline_count = text.count("\n")
+
+    if newline_count == 0:
+        return line, column + len(text)
+
+    line += newline_count
+
+    text_after_last_newline = text.rsplit("\n", maxsplit=1)[1]
+    column = len(text_after_last_newline) + 1
+
+    return line, column
+

basic_web_backend/template/nodes.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass, field
+
+class TemplateNode:
+    """Base class for template syntax nodes."""
+    pass
+
+@dataclass
+class TextNode(TemplateNode):
+    content: str
+    line: int = 1
+    column: int = 1
+
+@dataclass
+class VariableNode(TemplateNode):
+    path: list[str]
+    line: int = 1
+    column: int = 1
+
+@dataclass
+class IfNode(TemplateNode):
+    condition: list[str]
+    body: list[TemplateNode] = field(default_factory=list)
+    else_body: list[TemplateNode] = field(default_factory=list)
+    line: int = 1
+    column: int = 1
+
+@dataclass
+class ForNode(TemplateNode):
+    variable_name: str
+    iterable: list[str]
+    body: list[TemplateNode] = field(default_factory=list)
+    line: int = 1
+    column: int = 1
+

basic_web_backend/template/parser.py

@@ -0,0 +1,221 @@
+import re
+
+from ..exceptions import TemplateSyntaxError
+from .lexer import TokenType
+from .nodes import TextNode, VariableNode, IfNode, ForNode
+
+VARIABLE_PATH_PATTERN = re.compile(
+    r"[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*"
+)
+
+FOR_STATEMENT_PATTERN = re.compile(
+    r"for\s+(?P<variable>[A-Za-z_]\w*)"
+    r"\s+in\s+(?P<iterable>.+)"
+)
+
+def parse(tokens, template_name=None):
+    parser = Parser(tokens, template_name)
+    return parser.parse()
+
+class Parser:
+    def __init__(self, tokens, template_name=None):
+        self.tokens = list(tokens)
+        self.template_name = template_name
+        self.position = 0
+
+    def parse(self):
+        nodes, closing_statment = self._parse_nodes(stop_statements=set())
+
+        if closing_statment is not None:
+            token = self.tokens[self.position]
+
+            self._raise_unexpected_statment(token)
+
+        return nodes
+
+    def _parse_nodes(self, stop_statements):
+        nodes = []
+
+        while self.position < len(self.tokens):
+            token = self.tokens[self.position]
+
+            if token.type == TokenType.TEXT:
+                nodes.append(
+                    TextNode(
+                        content=token.value,
+                        line=token.line,
+                        column=token.column
+                    )
+                )
+                self.position += 1
+                continue
+
+            if token.type == TokenType.VARIABLE:
+                nodes.append(self._parse_variable(token))
+                self.position += 1
+                continue
+
+            if token.type == TokenType.STATEMENT:
+                statement = token.value
+
+                if statement in stop_statements:
+                    return nodes, statement
+
+                keyword = self._get_keyword(statement)
+
+                if keyword == "if":
+                    nodes.append(self._parse_if(opening_token=token))
+                    continue
+
+                if keyword == "for":
+                    nodes.append(self._parse_for(opening_token=token))
+                    continue
+
+                if statement in {"endif", "else", "endfor"}:
+                    self._raise_unexpected_statment(token)
+
+                self._raise_syntax_error(
+                    message=f"Unknown template statement: {statement}",
+                    token=token
+                )
+
+            self._raise_syntax_error(
+                message=f"Unkonwn template token type: {token.type}",
+                token=token
+            )
+
+        return nodes, None
+
+    def _parse_variable(self, token):
+        path = self._parse_variable_path(expression=token.value, token=token, empty_message="Variable expression cannot be empty.")
+
+        return VariableNode(
+            path=path,
+            line=token.line,
+            column=token.column
+        )
+
+    def _parse_if(self, opening_token):
+        parts = opening_token.value.split(maxsplit=1)
+
+        if len(parts) == 1:
+            self._raise_syntax_error(
+                message="If statement requires a condition.",
+                token=opening_token
+            )
+
+        condition_expression = parts[1].strip()
+
+        condition = self._parse_variable_path(
+            expression=condition_expression,
+            token=opening_token,
+            empty_message="If statement requires a condition."
+        )
+
+        self.position += 1
+
+        body, closing_statement = self._parse_nodes(stop_statements={"else", "endif"})
+
+        if closing_statement is None:
+            self._raise_syntax_error(
+                message="Missing endif statement.",
+                token=opening_token
+            )
+
+        else_body = []
+
+        if closing_statement == "else":
+            self.position += 1
+
+            else_body, closing_statement = self._parse_nodes(stop_statements={"endif"})
+
+            if closing_statement is None:
+                self._raise_syntax_error(
+                    message="Missing endif statement.",
+                    token=opening_token
+                )
+
+        self.position += 1
+
+        return IfNode(
+            condition=condition,
+            body=body,
+            else_body=else_body,
+            line=opening_token.line,
+            column=opening_token.column
+        )
+
+    def _parse_variable_path(self, expression, token, empty_message):
+        if not expression:
+            self._raise_syntax_error(
+                message=empty_message,
+                token=token
+            )
+
+        if VARIABLE_PATH_PATTERN.fullmatch(expression) is None:
+            self._raise_syntax_error(
+                message=f"Invalid variable expression: {expression}",
+                token=token
+            )
+
+        return expression.split(".")
+
+    def _get_keyword(self, statement):
+        parts = statement.split(maxsplit=1)
+        if not parts:
+            return ""
+
+        return parts[0]
+
+    def _raise_unexpected_statment(self, token):
+        self._raise_syntax_error(
+            message=f"Unexpected {token.value} statement.",
+            token=token
+        )
+
+    def _raise_syntax_error(self, message, token):
+        raise TemplateSyntaxError(
+            message=message,
+            template_name=self.template_name,
+            line=token.line,
+            column=token.column
+        )
+
+    def _parse_for(self, opening_token):
+        match = FOR_STATEMENT_PATTERN.fullmatch(opening_token.value)
+
+        if match is None:
+            self._raise_syntax_error(
+                message=f"Invalid for statement. Expected format: 'for <variable> in <iterable>'.",
+                token=opening_token
+            )
+
+        variable_name = match.group("variable")
+
+        iterable_expression = match.group("iterable").strip()
+
+        iterable = self._parse_variable_path(
+            expression=iterable_expression,
+            token=opening_token,
+            empty_message="Invalid for statement. Expected format: 'for <variable> in <iterable>'."
+        )
+
+        self.position += 1
+
+        body, closing_statement = self._parse_nodes(stop_statements={"endfor"})
+
+        if closing_statement is None:
+            self._raise_syntax_error(
+                message="Missing endfor statement.",
+                token=opening_token
+            )
+
+        self.position += 1
+
+        return ForNode(
+            variable_name=variable_name,
+            iterable=iterable,
+            body=body,
+            line=opening_token.line,
+            column=opening_token.column
+        )