pywire 0.1.0__py3-none-any.whl

pywire/compiler/directives/__init__.py

@@ -0,0 +1,7 @@
+"""Directive parsers."""
+
+from pywire.compiler.directives.base import DirectiveParser
+from pywire.compiler.directives.no_spa import NoSpaDirectiveParser
+from pywire.compiler.directives.path import PathDirectiveParser
+
+__all__ = ["DirectiveParser", "PathDirectiveParser", "NoSpaDirectiveParser"]

pywire/compiler/directives/base.py

@@ -0,0 +1,20 @@
+"""Base directive parser."""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from pywire.compiler.ast_nodes import Directive
+
+
+class DirectiveParser(ABC):
+    """Base class for parsing directives - extensible for new directives."""
+
+    @abstractmethod
+    def can_parse(self, line: str) -> bool:
+        """Check if this parser can handle the given line."""
+        pass
+
+    @abstractmethod
+    def parse(self, line: str, line_num: int, col_num: int) -> Optional[Directive]:
+        """Parse directive from line. Returns None if not applicable."""
+        pass

pywire/compiler/directives/component.py

@@ -0,0 +1,33 @@
+import re
+from typing import Optional
+
+from pywire.compiler.ast_nodes import ComponentDirective, Directive
+from pywire.compiler.directives.base import DirectiveParser
+
+
+class ComponentDirectiveParser(DirectiveParser):
+    """Parses !component 'path' as Name"""
+
+    def can_parse(self, line: str) -> bool:
+        return line.startswith("!component")
+
+    def parse(self, line: str, line_num: int, col_num: int) -> Optional[Directive]:
+        # Format: !component 'path/to/file' as ComponentName
+        # or !component "path/to/file" as ComponentName
+
+        # Regex to match: !component\s+['"](.+?)['"]\s+as\s+(\w+)
+        match = re.search(r"^!component\s+['\"](.+?)['\"]\s+as\s+(\w+)", line)
+        if not match:
+            # Maybe invalid format
+            return None
+
+        path = match.group(1)
+        name = match.group(2)
+
+        return ComponentDirective(
+            line=line_num,
+            column=col_num,
+            name="!component",
+            path=path,
+            component_name=name,
+        )

pywire/compiler/directives/context.py

@@ -0,0 +1,93 @@
+import ast
+from typing import Optional
+
+from pywire.compiler.ast_nodes import Directive, InjectDirective, ProvideDirective
+from pywire.compiler.directives.base import DirectiveParser
+
+
+class ContextDirectiveParser(DirectiveParser):
+    """Parses !inject and !provide"""
+
+    def can_parse(self, line: str) -> bool:
+        return line.startswith("!inject") or line.startswith("!provide")
+
+    def parse(self, line: str, line_num: int, col_num: int) -> Optional[Directive]:
+        is_inject = line.startswith("!inject")
+        directive_name = "!inject" if is_inject else "!provide"
+
+        content = line[len(directive_name) :].strip()
+
+        # Wrapped in dict braces?
+        if not content.startswith("{") or not content.endswith("}"):
+            # Maybe they omitted braces? Let's assume strict syntax for now as per design doc
+            # !inject { ... }
+            return None
+
+        try:
+            # Parse as a dictionary expression
+            # code: _ = { ... }
+            dummy_code = f"_ = {content}"
+            mod = ast.parse(dummy_code)
+            assign = mod.body[0]
+            if not isinstance(assign, ast.Assign) or not isinstance(
+                assign.value, ast.Dict
+            ):
+                return None
+
+            dict_node = assign.value
+
+            mapping = {}
+
+            for key_node, value_node in zip(dict_node.keys, dict_node.values):
+                if is_inject:
+                    # !inject { local_var: 'GLOBAL_KEY' }
+                    # key should be the local variable name (Name node or Constant string)
+                    # value should be the context key (Constant string)
+
+                    local_var = None
+                    if isinstance(key_node, ast.Name):
+                        local_var = key_node.id
+                    elif isinstance(key_node, ast.Constant) and isinstance(
+                        key_node.value, str
+                    ):
+                        local_var = key_node.value
+
+                    global_key = None
+                    if isinstance(value_node, ast.Constant) and isinstance(
+                        value_node.value, str
+                    ):
+                        global_key = value_node.value
+
+                    if local_var and global_key:
+                        mapping[local_var] = global_key
+
+                else:
+                    # !provide { 'GLOBAL_KEY': local_expr }
+                    # key must be string
+                    # value is expression to be evaluated at runtime
+
+                    global_key = None
+                    if isinstance(key_node, ast.Constant) and isinstance(
+                        key_node.value, str
+                    ):
+                        global_key = key_node.value
+
+                    # Convert value node back to source string to be put in generated code
+                    val_expr = ""
+                    if hasattr(ast, "unparse"):
+                        val_expr = ast.unparse(value_node)
+
+                    if global_key:
+                        mapping[global_key] = val_expr
+
+            if is_inject:
+                return InjectDirective(
+                    line=line_num, column=col_num, name="!inject", mapping=mapping
+                )
+            else:
+                return ProvideDirective(
+                    line=line_num, column=col_num, name="!provide", mapping=mapping
+                )
+
+        except Exception:
+            return None

pywire/compiler/directives/layout.py

@@ -0,0 +1,49 @@
+"""Layout directive parser."""
+
+import ast
+import re
+from typing import Optional
+
+from pywire.compiler.ast_nodes import LayoutDirective
+from pywire.compiler.directives.base import DirectiveParser
+
+
+class LayoutDirectiveParser(DirectiveParser):
+    """Parses !layout directives."""
+
+    PATTERN = re.compile(r"^!layout\s+(.+)$", re.DOTALL)
+
+    def can_parse(self, line: str) -> bool:
+        """Check if line starts with !layout."""
+        return line.strip().startswith("!layout")
+
+    def parse(
+        self, line: str, line_num: int, col_num: int
+    ) -> Optional[LayoutDirective]:
+        """Parse !layout "path/to/layout" directive."""
+        match = self.PATTERN.match(line.strip())
+        if not match:
+            return None
+
+        path_str = match.group(1).strip()
+        if not path_str:
+            return None
+
+        try:
+            # Parse python string
+            # We expect a simple string literal
+            expr_ast = ast.parse(path_str, mode="eval")
+
+            if isinstance(expr_ast.body, ast.Constant) and isinstance(
+                expr_ast.body.value, str
+            ):
+                return LayoutDirective(
+                    name="layout",
+                    layout_path=expr_ast.body.value,
+                    line=line_num,
+                    column=col_num,
+                )
+
+            return None
+        except (SyntaxError, ValueError, AttributeError):
+            return None

pywire/compiler/directives/no_spa.py

@@ -0,0 +1,24 @@
+"""No-SPA directive parser."""
+
+import re
+from typing import Optional
+
+from pywire.compiler.ast_nodes import NoSpaDirective
+from pywire.compiler.directives.base import DirectiveParser
+
+
+class NoSpaDirectiveParser(DirectiveParser):
+    """Parses !no_spa directive to disable client-side navigation."""
+
+    PATTERN = re.compile(r"^!no_spa\s*$")
+
+    def can_parse(self, line: str) -> bool:
+        """Check if line is !no_spa."""
+        return line.strip() == "!no_spa"
+
+    def parse(self, line: str, line_num: int, col_num: int) -> Optional[NoSpaDirective]:
+        """Parse !no_spa directive."""
+        if not self.PATTERN.match(line.strip()):
+            return None
+
+        return NoSpaDirective(name="no_spa", line=line_num, column=col_num)

pywire/compiler/directives/path.py

@@ -0,0 +1,71 @@
+"""Path directive parser."""
+
+import ast
+import re
+from typing import Dict, Optional
+
+from pywire.compiler.ast_nodes import PathDirective
+from pywire.compiler.directives.base import DirectiveParser
+
+
+class PathDirectiveParser(DirectiveParser):
+    """Parses !path directives."""
+
+    PATTERN = re.compile(r"^!path\s+(.+)$", re.DOTALL)
+
+    def can_parse(self, line: str) -> bool:
+        """Check if line starts with !path."""
+        return line.strip().startswith("!path")
+
+    def parse(self, line: str, line_num: int, col_num: int) -> Optional[PathDirective]:
+        """Parse !path { 'name': '/route' } directive."""
+        match = self.PATTERN.match(line.strip())
+        if not match:
+            return None
+
+        routes_str = match.group(1).strip()
+        if not routes_str:
+            return None
+
+        try:
+            # Parse python expression
+            expr_ast = ast.parse(routes_str, mode="eval")
+
+            # Case 1: Dictionary !path {'main': '/'}
+            if isinstance(expr_ast.body, ast.Dict):
+                routes: Dict[str, str] = {}
+                for key_node, value_node in zip(
+                    expr_ast.body.keys, expr_ast.body.values
+                ):
+                    if (
+                        not isinstance(key_node, ast.Constant)
+                        or not isinstance(key_node.value, str)
+                        or not isinstance(value_node, ast.Constant)
+                        or not isinstance(value_node.value, str)
+                    ):
+                        return None
+                    routes[key_node.value] = value_node.value
+
+                return PathDirective(
+                    name="path",
+                    routes=routes,
+                    is_simple_string=False,
+                    line=line_num,
+                    column=col_num,
+                )
+
+            # Case 2: String !path '/test'
+            elif isinstance(expr_ast.body, ast.Constant) and isinstance(
+                expr_ast.body.value, str
+            ):
+                return PathDirective(
+                    name="path",
+                    routes={"main": expr_ast.body.value},
+                    is_simple_string=True,
+                    line=line_num,
+                    column=col_num,
+                )
+
+            return None
+        except (SyntaxError, ValueError, AttributeError):
+            return None

pywire/compiler/directives/props.py

@@ -0,0 +1,88 @@
+import ast
+from typing import List, Optional, Tuple
+
+from pywire.compiler.ast_nodes import Directive, PropsDirective
+from pywire.compiler.directives.base import DirectiveParser
+
+
+class PropsDirectiveParser(DirectiveParser):
+    """Parses !props(name: type, arg=default)"""
+
+    def can_parse(self, line: str) -> bool:
+        return line.startswith("!props")
+
+    def parse(self, line: str, line_num: int, col_num: int) -> Optional[Directive]:
+        # Format: !props(arg: type, arg2=default)
+
+        # 1. Extract content inside parentheses
+        # Note: 'line' might be multiline string passed from parser.
+        # We assume the parser handles accumulation until matching parens if needed.
+        # Or we rely on the fact that directives are usually single line or we need to handle it.
+        # The main parser accumulates if braces/brackets match, but what about parens?
+        # The main parser logic: "Count open braces/brackets". It does NOT count parens currently.
+        # We might need to update the main parser to also count parens for !props?
+        # For now, let's assume it's passed correctly or single line.
+
+        # Strip '!props'
+        content = line[len("!props") :].strip()
+        if not content.startswith("(") or not content.endswith(")"):
+            return None
+
+        # content is "(...)"
+
+        # 2. Use AST parsing by wrapping in a function def
+        # This handles complex types, strings with commas, etc.
+        dummy_code = f"def _p{content}: pass"
+
+        try:
+            mod = ast.parse(dummy_code)
+            func_def = mod.body[0]
+            if not isinstance(func_def, ast.FunctionDef):
+                return None
+
+            args = func_def.args
+
+            parsed_args: List[Tuple[str, str, Optional[str]]] = []
+
+            # Helper to get source segment if possible, or unparse
+            def unparse_node(node: ast.AST) -> str:
+                if hasattr(ast, "unparse"):
+                    source = ast.unparse(node)
+                    # ast.unparse might return something slightly different formatted,
+                    # which is fine for type strings
+                    return source
+                return ""  # Fallback for older python if needed, but we likely preserve 3.9+
+
+            # Process args (normal arguments)
+            # defaults are at the end of the list.
+            # e.g. args.args = [a, b], args.defaults = [def_b] -> a has no default, b has def_b
+
+            num_args = len(args.args)
+            num_defaults = len(args.defaults)
+            offset = num_args - num_defaults
+
+            for i, arg in enumerate(args.args):
+                name = arg.arg
+                type_hint = "Any"
+                if arg.annotation:
+                    type_hint = unparse_node(arg.annotation)
+
+                default_val = None
+                if i >= offset:
+                    default_idx = i - offset
+                    default_val = unparse_node(args.defaults[default_idx])
+
+                parsed_args.append((name, type_hint, default_val))
+
+            # TODO: Handle kwonlyargs if we want to enforce keyword only props?
+            # For now simple args.
+
+            return PropsDirective(
+                line=line_num, column=col_num, name="!props", args=parsed_args
+            )
+
+        except SyntaxError:
+            # Invalid python syntax in props
+            return None
+        except Exception:
+            return None

pywire/compiler/exceptions.py

@@ -0,0 +1,19 @@
+"""Compiler exceptions."""
+
+
+class PyWireSyntaxError(Exception):
+    """Raised when PyWire syntax is invalid."""
+
+    def __init__(
+        self, message: str, file_path: str = "", line: int = 0, column: int = 0
+    ):
+        self.message = message
+        self.file_path = file_path
+        self.line = line
+        self.column = column
+        super().__init__(message)
+
+    def __str__(self) -> str:
+        if self.file_path and self.line:
+            return f"{self.file_path}:{self.line}: {self.message}"
+        return self.message

pywire/compiler/interpolation/__init__.py

@@ -0,0 +1,6 @@
+"""Interpolation parsers."""
+
+from pywire.compiler.interpolation.base import InterpolationParser
+from pywire.compiler.interpolation.jinja import JinjaInterpolationParser
+
+__all__ = ["InterpolationParser", "JinjaInterpolationParser"]

pywire/compiler/interpolation/base.py

@@ -0,0 +1,28 @@
+"""Base interpolation parser."""
+
+from abc import ABC, abstractmethod
+from typing import List, Union
+
+from pywire.compiler.ast_nodes import InterpolationNode
+
+
+class InterpolationParser(ABC):
+    """Base class for parsing interpolations - can swap Jinja for custom later."""
+
+    @abstractmethod
+    def parse(
+        self, text: str, line: int, col: int
+    ) -> List[Union[str, InterpolationNode]]:
+        """
+        Parse text with interpolations into mix of strings and InterpolationNodes.
+        Returns: ['Hello, ', InterpolationNode(expr='name'), '!']
+        """
+        pass
+
+    @abstractmethod
+    def compile(self, text: str) -> str:
+        """
+        Compile to Python code for runtime.
+        'Hello {name}!' → f'Hello {self.name}!'
+        """
+        pass