mapres 3.dev21__tar.gz → 3.dev23__tar.gz

{mapres-3.dev21/src/mapres.egg-info → mapres-3.dev23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapres
-Version: 3.dev21
+Version: 3.dev23
 Summary: A powerfull mapping utility
 Author: iFamished
 License: MIT

{mapres-3.dev21 → mapres-3.dev23}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mapres"
-version = "3-dev.21"
+version = "3-dev.23"
 description = "A powerfull mapping utility"
 readme = "README.md"
 requires-python = ">=3.9"

{mapres-3.dev21 → mapres-3.dev23}/src/mapres/parser.py

@@ -22,11 +22,10 @@ class Parser:
     def expect(self, type_: TokenType) -> Token:
         tok = self.peek()
         if tok is None or tok.type != type_:
-            raise ParserError(f"Expected {type_}, got {tok}")
+            raise ParserError(f'Expected {type_}, got {tok}')
         self.advance()
         return tok
 
-    # top-level template parse
     def parse(self) -> TemplateNode:
         children: list[Node] = []
         while self.peek() is not None:
@@ -38,88 +37,76 @@ class Parser:
                 children.append(self.parse_token())
         return TemplateNode(children)
 
-    # nested template parse (for IDENT(...))
     def parse_until(self, stop_types: tuple[TokenType, ...]) -> TemplateNode:
         children: list[Node] = []
         while True:
             tok = self.peek()
             if tok is None or tok.type in stop_types:
                 break
-
             if tok.type is TokenType.TEXT:
                 children.append(TextNode(tok.value))
                 self.advance()
             else:
                 children.append(self.parse_token())
-
         return TemplateNode(children)
 
-    # dispatch by opening delimiter
     def parse_token(self) -> Node:
         tok = self.peek()
 
         if tok.type is TokenType.COLON_OPEN:
-            return self.parse_colon_token()
+            return self.parse_colon()
 
         if tok.type is TokenType.BRACE_OPEN:
-            return self.parse_brace_token()
+            return self.parse_brace()
 
         if tok.type is TokenType.DOLLAR_OPEN:
-            return self.parse_dollar_token()
+            return self.parse_dollar()
 
         if tok.type is TokenType.ANGLE_OPEN:
-            return self.parse_angle_token()
+            return self.parse_angle()
 
         if tok.type is TokenType.PIPE_OPEN:
-            return self.parse_pipe_token()
+            return self.parse_pipe()
 
         if tok.type is TokenType.PERCENT_OPEN:
-            return self.parse_percent_token()
+            return self.parse_percent()
 
-        raise ParserError(f"Unexpected token {tok}")
+        raise ParserError(f'Unexpected token {tok}')
 
-    # core pattern: IDENT or IDENT(arg)
     def _parse_ident_or_call(self, closing_type: TokenType, syntax_name: str) -> Node:
         ident_tok = self.expect(TokenType.IDENT)
         name = ident_tok.value
 
-        # IDENT(arg)
         if self.peek() and self.peek().type is TokenType.LPAREN:
-            self.advance()  # consume '('
-
-            # parse only until RPAREN
+            self.advance()
             arg = self.parse_until((TokenType.RPAREN,))
-
             self.expect(TokenType.RPAREN)
             self.expect(closing_type)
             return CallNode(name=name, arg=arg, syntax=syntax_name)
 
-        # IDENT
         self.expect(closing_type)
         return IdentNode(name=name, syntax=syntax_name)
 
-    # --- syntax-bound token handlers ---
-
-    def parse_colon_token(self) -> Node:
+    def parse_colon(self) -> Node:
         self.expect(TokenType.COLON_OPEN)
-        return self._parse_ident_or_call(TokenType.COLON_CLOSE, "colons")
+        return self._parse_ident_or_call(TokenType.COLON_CLOSE, 'colons')
 
-    def parse_brace_token(self) -> Node:
+    def parse_brace(self) -> Node:
         self.expect(TokenType.BRACE_OPEN)
-        return self._parse_ident_or_call(TokenType.BRACE_CLOSE, "braces")
+        return self._parse_ident_or_call(TokenType.BRACE_CLOSE, 'braces')
 
-    def parse_dollar_token(self) -> Node:
+    def parse_dollar(self) -> Node:
         self.expect(TokenType.DOLLAR_OPEN)
-        return self._parse_ident_or_call(TokenType.DOLLAR_CLOSE, "dollars")
+        return self._parse_ident_or_call(TokenType.DOLLAR_CLOSE, 'dollars')
 
-    def parse_angle_token(self) -> Node:
+    def parse_angle(self) -> Node:
         self.expect(TokenType.ANGLE_OPEN)
-        return self._parse_ident_or_call(TokenType.ANGLE_CLOSE, "angles")
+        return self._parse_ident_or_call(TokenType.ANGLE_CLOSE, 'angles')
 
-    def parse_pipe_token(self) -> Node:
+    def parse_pipe(self) -> Node:
         self.expect(TokenType.PIPE_OPEN)
-        return self._parse_ident_or_call(TokenType.PIPE_CLOSE, "pipes")
+        return self._parse_ident_or_call(TokenType.PIPE_CLOSE, 'pipes')
 
-    def parse_percent_token(self) -> Node:
+    def parse_percent(self) -> Node:
         self.expect(TokenType.PERCENT_OPEN)
-        return self._parse_ident_or_call(TokenType.PERCENT_CLOSE, "percents")
+        return self._parse_ident_or_call(TokenType.PERCENT_CLOSE, 'percents')

mapres-3.dev23/src/mapres/tokenizer.py

@@ -0,0 +1,248 @@
+from enum import Enum, auto
+
+
+class TokenType(Enum):
+    TEXT = auto()
+    IDENT = auto()
+    COLON_OPEN = auto()
+    COLON_CLOSE = auto()
+    BRACE_OPEN = auto()
+    BRACE_CLOSE = auto()
+    DOLLAR_OPEN = auto()
+    DOLLAR_CLOSE = auto()
+    ANGLE_OPEN = auto()
+    ANGLE_CLOSE = auto()
+    PIPE_OPEN = auto()
+    PIPE_CLOSE = auto()
+    PERCENT_OPEN = auto()
+    PERCENT_CLOSE = auto()
+    LPAREN = auto()
+    RPAREN = auto()
+
+
+class Token:
+    def __init__(self, type_, value=None, pos=0):
+        self.type = type_
+        self.value = value
+        self.pos = pos
+
+    def __repr__(self):
+        if self.value is not None:
+            return f'Token({self.type}, {self.value!r}, pos={self.pos})'
+        return f'Token({self.type}, pos={self.pos})'
+
+
+class Tokenizer:
+    def __init__(self, text: str):
+        self.text = text
+        self.i = 0
+        self.n = len(text)
+        self.tokens: list[Token] = []
+
+    def peek(self, k: int = 0) -> str:
+        idx = self.i + k
+        if idx >= self.n:
+            return ''
+        return self.text[idx]
+
+    def advance(self, k: int = 1) -> None:
+        self.i += k
+
+    def match(self, s: str) -> bool:
+        return self.text.startswith(s, self.i)
+
+    def emit(self, type_, value=None) -> None:
+        self.tokens.append(Token(type_, value, self.i))
+
+    def tokenize(self) -> list[Token]:
+        buf: list[str] = []
+
+        def flush_text():
+            if buf:
+                self.emit(TokenType.TEXT, ''.join(buf))
+                buf.clear()
+
+        while self.i < self.n:
+            ch = self.peek()
+
+            # escapes
+            if self.match(r'\:'):
+                buf.append(':'); self.advance(2); continue
+            if self.match(r'\<'):
+                buf.append('<'); self.advance(2); continue
+            if self.match(r'\>'):
+                buf.append('>'); self.advance(2); continue
+            if self.match(r'\%'):
+                buf.append('%'); self.advance(2); continue
+            if self.match(r'\$'):
+                buf.append('$'); self.advance(2); continue
+            if self.match(r'\{'):
+                buf.append('{'); self.advance(2); continue
+            if self.match(r'\}'):
+                buf.append('}'); self.advance(2); continue
+            if self.match(r'\|'):
+                buf.append('|'); self.advance(2); continue
+            if self.match(r'\('):
+                buf.append('('); self.advance(2); continue
+            if self.match(r'\)'):
+                buf.append(')'); self.advance(2); continue
+
+            # --- {{IDENT}} ---
+            if self.match('{{'):
+                flush_text()
+                start = self.i
+                self.advance(2)
+                ident = self._read_ident()
+                if ident is not None and self.match('}}'):
+                    self.emit(TokenType.BRACE_OPEN)
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance(2)
+                    self.emit(TokenType.BRACE_CLOSE)
+                    continue
+                self.i = start
+                buf.append(self.peek())
+                self.advance()
+                continue
+
+            # --- ${IDENT} ---
+            if self.match('${'):
+                flush_text()
+                start = self.i
+                self.advance(2)
+                ident = self._read_ident()
+                if ident is not None and self.peek() == '}':
+                    self.emit(TokenType.DOLLAR_OPEN)
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
+                    self.emit(TokenType.DOLLAR_CLOSE)
+                    continue
+                self.i = start
+                buf.append(self.peek())
+                self.advance()
+                continue
+
+            # --- $(IDENT) ---
+            if self.match('$('):
+                flush_text()
+                start = self.i
+                self.advance(2)
+                ident = self._read_ident()
+                if ident is not None and self.peek() == ')':
+                    self.emit(TokenType.DOLLAR_OPEN)
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
+                    self.emit(TokenType.DOLLAR_CLOSE)
+                    continue
+                self.i = start
+                buf.append(self.peek())
+                self.advance()
+                continue
+
+            # --- <IDENT> ---
+            if ch == '<':
+                flush_text()
+                start = self.i
+                self.advance()
+                ident = self._read_ident()
+                if ident is not None and self.peek() == '>':
+                    self.emit(TokenType.ANGLE_OPEN)
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
+                    self.emit(TokenType.ANGLE_CLOSE)
+                    continue
+                self.i = start
+                buf.append(self.peek())
+                self.advance()
+                continue
+
+            # --- |IDENT| ---
+            if ch == '|':
+                flush_text()
+                start = self.i
+                self.advance()
+                ident = self._read_ident()
+                if ident is not None and self.peek() == '|':
+                    self.emit(TokenType.PIPE_OPEN)
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
+                    self.emit(TokenType.PIPE_CLOSE)
+                    continue
+                self.i = start
+                buf.append(self.peek())
+                self.advance()
+                continue
+
+            # --- %IDENT% ---
+            if ch == '%':
+                flush_text()
+                start = self.i
+                self.advance()
+                ident = self._read_ident()
+                if ident is not None and self.peek() == '%':
+                    self.emit(TokenType.PERCENT_OPEN)
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
+                    self.emit(TokenType.PERCENT_CLOSE)
+                    continue
+                self.i = start
+                buf.append(self.peek())
+                self.advance()
+                continue
+
+            # --- :IDENT: ---
+            if ch == ':':
+                flush_text()
+                start = self.i
+                self.advance()
+                ident = self._read_ident()
+                if ident is not None and self.peek() == ':':
+                    self.emit(TokenType.COLON_OPEN)
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
+                    self.emit(TokenType.COLON_CLOSE)
+                    continue
+                self.i = start
+                buf.append(self.peek())
+                self.advance()
+                continue
+
+            # --- parens ---
+            if ch == '(':
+                flush_text()
+                self.emit(TokenType.LPAREN)
+                self.advance()
+                continue
+
+            if ch == ')':
+                flush_text()
+                self.emit(TokenType.RPAREN)
+                self.advance()
+                continue
+
+            # fallback TEXT
+            buf.append(ch)
+            self.advance()
+
+        flush_text()
+        return self.tokens
+
+    def _read_ident(self) -> str | None:
+        start = self.i
+        ch = self.peek()
+        if not ch or not ch.isalnum():
+            return None
+
+        self.advance()
+        while True:
+            nxt = self.peek()
+            if not nxt:
+                break
+            if nxt.isalnum() or nxt in '._':
+                self.advance()
+            else:
+                break
+
+        ident = self.text[start:self.i]
+        if ident.startswith('_') or ident.endswith('_') or '-' in ident:
+            return None
+        return ident

{mapres-3.dev21 → mapres-3.dev23/src/mapres.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapres
-Version: 3.dev21
+Version: 3.dev23
 Summary: A powerfull mapping utility
 Author: iFamished
 License: MIT

mapres-3.dev21/src/mapres/tokenizer.py

@@ -1,232 +0,0 @@
-from enum import Enum, auto
-
-
-class TokenType(Enum):
-    TEXT = auto()
-    IDENT = auto()
-    COLON_OPEN = auto()
-    COLON_CLOSE = auto()
-    BRACE_OPEN = auto()
-    BRACE_CLOSE = auto()
-    DOLLAR_OPEN = auto()
-    DOLLAR_CLOSE = auto()
-    ANGLE_OPEN = auto()
-    ANGLE_CLOSE = auto()
-    PIPE_OPEN = auto()
-    PIPE_CLOSE = auto()
-    PERCENT_OPEN = auto()
-    PERCENT_CLOSE = auto()
-    LPAREN = auto()
-    RPAREN = auto()
-
-
-class Token:
-    def __init__(self, type_, value=None, pos=0):
-        self.type = type_
-        self.value = value
-        self.pos = pos
-
-    def __repr__(self):
-        if self.value is not None:
-            return f'Token({self.type}, {self.value!r}, pos={self.pos})'
-        return f'Token({self.type}, pos={self.pos})'
-
-
-class Tokenizer:
-    def __init__(self, text):
-        self.text = text
-        self.i = 0
-        self.n = len(text)
-        self.tokens = []
-
-        # toggle states
-        self.in_pipe = False
-        self.in_percent = False
-        self.in_colon = False
-
-        # mixed states
-        self.in_dollar = False
-
-    def peek(self, k=0):
-        idx = self.i + k
-        if idx >= self.n:
-            return ''
-        return self.text[idx]
-
-    def advance(self, k=1):
-        self.i += k
-
-    def match(self, s):
-        return self.text.startswith(s, self.i)
-
-    def emit(self, type_, value=None):
-        self.tokens.append(Token(type_, value, self.i))
-
-    def tokenize(self):
-        buf = []
-
-        def flush_text():
-            if buf:
-                self.emit(TokenType.TEXT, ''.join(buf))
-                buf.clear()
-
-        while self.i < self.n:
-            ch = self.peek()
-
-            # escapes
-            if self.match(r'\:'):
-                buf.append(':'); self.advance(2); continue
-            if self.match(r'\<'):
-                buf.append('<'); self.advance(2); continue
-            if self.match(r'\>'):
-                buf.append('>'); self.advance(2); continue
-            if self.match(r'\%'):
-                buf.append('%'); self.advance(2); continue
-            if self.match(r'\$'):
-                buf.append('$'); self.advance(2); continue
-            if self.match(r'\{'):
-                buf.append('{'); self.advance(2); continue
-            if self.match(r'\}'):
-                buf.append('}'); self.advance(2); continue
-            if self.match(r'\|'):
-                buf.append('|'); self.advance(2); continue
-            if self.match(r'\('):
-                buf.append('('); self.advance(2); continue
-            if self.match(r'\)'):
-                buf.append(')'); self.advance(2); continue
-
-            # --- paired delimiters ---
-
-            # braces {{ }}
-            if self.match('{{'):
-                flush_text()
-                self.emit(TokenType.BRACE_OPEN)
-                self.advance(2)
-                continue
-
-            if self.match('}}'):
-                flush_text()
-                self.emit(TokenType.BRACE_CLOSE)
-                self.advance(2)
-                continue
-
-            # angles < >
-            if self.match('<'):
-                flush_text()
-                self.emit(TokenType.ANGLE_OPEN)
-                self.advance()
-                continue
-
-            if self.match('>'):
-                flush_text()
-                self.emit(TokenType.ANGLE_CLOSE)
-                self.advance()
-                continue
-
-            # --- mixed delimiters (dollars) ---
-
-            if self.match('${'):
-                flush_text()
-                self.emit(TokenType.DOLLAR_OPEN)
-                self.in_dollar = True
-                self.advance(2)
-                continue
-
-            if ch == '}':
-                flush_text()
-                if self.in_dollar:
-                    self.emit(TokenType.DOLLAR_CLOSE)
-                    self.in_dollar = False
-                else:
-                    buf.append('}')
-                self.advance()
-                continue
-
-            # --- toggle delimiters ---
-
-            # pipes |...|
-            if self.match('|'):
-                flush_text()
-                if not self.in_pipe:
-                    self.emit(TokenType.PIPE_OPEN)
-                    self.in_pipe = True
-                else:
-                    self.emit(TokenType.PIPE_CLOSE)
-                    self.in_pipe = False
-                self.advance()
-                continue
-
-            # percents %...%
-            if self.match('%'):
-                flush_text()
-                if not self.in_percent:
-                    self.emit(TokenType.PERCENT_OPEN)
-                    self.in_percent = True
-                else:
-                    self.emit(TokenType.PERCENT_CLOSE)
-                    self.in_percent = False
-                self.advance()
-                continue
-
-            # colons :...:
-            if self.match(':'):
-                flush_text()
-                if not self.in_colon:
-                    self.emit(TokenType.COLON_OPEN)
-                    self.in_colon = True
-                else:
-                    self.emit(TokenType.COLON_CLOSE)
-                    self.in_colon = False
-                self.advance()
-                continue
-
-            # --- parens ---
-
-            if ch == '(':
-                flush_text()
-                self.emit(TokenType.LPAREN)
-                self.advance()
-                continue
-
-            if ch == ')':
-                flush_text()
-                self.emit(TokenType.RPAREN)
-                self.advance()
-                continue
-
-            # --- IDENT (your rules) ---
-
-            if ch.isalnum():
-                flush_text()
-                start = self.i
-
-                # first char: [a-zA-Z0-9]
-                self.advance()
-
-                # middle chars: [a-zA-Z0-9._]*
-                while True:
-                    nxt = self.peek()
-                    if not nxt:
-                        break
-                    if nxt.isalnum() or nxt in '._':
-                        self.advance()
-                    else:
-                        break
-
-                ident = self.text[start:self.i]
-
-                # enforce: no leading/trailing '_', no '-'
-                if ident.startswith('_') or ident.endswith('_') or '-' in ident:
-                    # treat as TEXT instead
-                    buf.append(ident)
-                else:
-                    self.emit(TokenType.IDENT, ident)
-                continue
-
-            # --- fallback: TEXT ---
-
-            buf.append(ch)
-            self.advance()
-
-        flush_text()
-        return self.tokens