mapres 3.dev6__py3-none-any.whl → 3.dev8__py3-none-any.whl

mapres/parser.py

@@ -12,22 +12,23 @@ class Parser:
         self.i = 0
         self.n = len(tokens)
 
-    def peek(self, k=0) -> Token | None:
+    def peek(self, k: int = 0) -> Token | None:
         idx = self.i + k
         return self.tokens[idx] if idx < self.n else None
 
-    def advance(self, k=1):
+    def advance(self, k: int = 1) -> None:
         self.i += k
 
-    def expect(self, type_: TokenType):
+    def expect(self, type_: TokenType) -> Token:
         tok = self.peek()
         if tok is None or tok.type != type_:
             raise ParserError(f"Expected {type_}, got {tok}")
         self.advance()
         return tok
 
+    # top-level template parse
     def parse(self) -> TemplateNode:
-        children = []
+        children: list[Node] = []
         while self.peek() is not None:
             tok = self.peek()
             if tok.type is TokenType.TEXT:
@@ -37,6 +38,23 @@ 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()
 
@@ -60,21 +78,23 @@ class Parser:
 
         raise ParserError(f"Unexpected token {tok}")
 
-    # --- core pattern: IDENT or IDENT(arg) ---
-
-    def _parse_ident_or_call(self, closing_type, syntax_name: str) -> Node:
+    # 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
 
-        # single-argument nested form: IDENT LPAREN Template RPAREN
+        # IDENT(arg)
         if self.peek() and self.peek().type is TokenType.LPAREN:
             self.advance()  # consume '('
-            arg = self.parse()  # nested Template
+
+            # parse only until RPAREN
+            arg = self.parse_until((TokenType.RPAREN,))
+
             self.expect(TokenType.RPAREN)
             self.expect(closing_type)
             return CallNode(name=name, arg=arg, syntax=syntax_name)
 
-        # simple identifier: IDENT
+        # IDENT
         self.expect(closing_type)
         return IdentNode(name=name, syntax=syntax_name)
 

mapres/tokenizer.py

@@ -46,6 +46,11 @@ class Tokenizer:
         self.n = len(text)
         self.tokens = []
 
+        # state for single-char paired delimiters
+        self.in_pipe = False
+        self.in_percent = False
+        self.in_colon = False
+
     def peek(self, k=0):
         idx = self.i + k
         if idx >= self.n:
@@ -72,9 +77,7 @@ class Tokenizer:
         while self.i < self.n:
             ch = self.peek()
 
-            # ------------------------------------
-            # ESCAPING: \X → literal X
-            # ------------------------------------
+            # ESCAPES
             if self.match(r'\:'):
                 buf.append(':'); self.advance(2); continue
             if self.match(r'\<'):
@@ -96,9 +99,7 @@ class Tokenizer:
             if self.match(r'\)'):
                 buf.append(')'); self.advance(2); continue
 
-            # ------------------------------------
             # DOUBLE BRACES {{value}}
-            # ------------------------------------
             if self.match("{{"):
                 flush_text()
                 self.emit(TokenType.BRACE_OPEN)
@@ -111,9 +112,7 @@ class Tokenizer:
                 self.advance(2)
                 continue
 
-            # ------------------------------------
             # DOLLARS ${value}
-            # ------------------------------------
             if self.match("${"):
                 flush_text()
                 self.emit(TokenType.DOLLAR_OPEN)
@@ -126,9 +125,7 @@ class Tokenizer:
                 self.advance()
                 continue
 
-            # ------------------------------------
             # ANGLES <value>
-            # ------------------------------------
             if self.match("<"):
                 flush_text()
                 self.emit(TokenType.ANGLE_OPEN)
@@ -141,48 +138,43 @@ class Tokenizer:
                 self.advance()
                 continue
 
-            # ------------------------------------
             # PIPES |value|
-            # ------------------------------------
             if self.match("|"):
                 flush_text()
-                # explicit open/close detection:
-                # |IDENT| → PIPE_OPEN IDENT PIPE_CLOSE
-                # parser enforces structure
-                if self.tokens and self.tokens[-1].type == TokenType.PIPE_OPEN:
-                    self.emit(TokenType.PIPE_CLOSE)
-                else:
+                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 %value%
-            # ------------------------------------
             if self.match("%"):
                 flush_text()
-                if self.tokens and self.tokens[-1].type == TokenType.PERCENT_OPEN:
-                    self.emit(TokenType.PERCENT_CLOSE)
-                else:
+                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 :value:
-            # ------------------------------------
             if self.match(":"):
                 flush_text()
-                if self.tokens and self.tokens[-1].type == TokenType.COLON_OPEN:
-                    self.emit(TokenType.COLON_CLOSE)
-                else:
+                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
 
-            # ------------------------------------
             # PARENTHESES
-            # ------------------------------------
             if ch == "(":
                 flush_text()
                 self.emit(TokenType.LPAREN)
@@ -195,9 +187,7 @@ class Tokenizer:
                 self.advance()
                 continue
 
-            # ------------------------------------
             # IDENTIFIERS (with dots)
-            # ------------------------------------
             if ch.isalpha():
                 flush_text()
                 start = self.i
@@ -207,9 +197,7 @@ class Tokenizer:
                 self.emit(TokenType.IDENT, ident)
                 continue
 
-            # ------------------------------------
             # DEFAULT: TEXT
-            # ------------------------------------
             buf.append(ch)
             self.advance()
 

{mapres-3.dev6.dist-info → mapres-3.dev8.dist-info}/METADATA

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

{mapres-3.dev6.dist-info → mapres-3.dev8.dist-info}/RECORD

@@ -5,14 +5,14 @@ mapres/datamap.py,sha256=HAflZFD9eh2VRkR9_2aDtXxY3r_A5ZUnpxNJ_VqmFBE,3837
 mapres/evaluator.py,sha256=-MsLxUlmYIOz5IOR5KT8IclJXtABGukLoQVmqkOTqTA,3780
 mapres/exceptions.py,sha256=jirHKK5yCffSCWWkgZY_gTSIOaFCmXOe5NJJf60HeeQ,130
 mapres/layers.py,sha256=sFc1eUOBg2BoB2cBXIleq8RMYcg5GZpUoCnGh-uKN6U,1380
-mapres/parser.py,sha256=xCnR290-A_XI8Yr8u1V-K_Of8exhGFOz5aT6gjAeBGA,3405
+mapres/parser.py,sha256=8XLCzYosvh81bN-Jddc1AM4w0X7bsHnBzmA8sq5_72w,4018
 mapres/resolver.py,sha256=LOAnuNc1RW97eBXughkEPK90MntMSYa7yC8s1EJPVvA,3134
-mapres/tokenizer.py,sha256=vQDy9Fw1rIDLcqs3jlcbZ0VI6mcK0U5h3SJ_jqpH45g,6627
+mapres/tokenizer.py,sha256=zw1jhnfypak1bLSTlyo9Xj4UoOF9DJ3y1qqu2OzudiI,5702
 mapres/maps/__init__.py,sha256=lIRRfem1Fw4iynuwUQ7BY5qrC4fbJKxqLivao2_Dtm4,239
 mapres/maps/color.py,sha256=noRTGFNo9xLl5YEhX0tttV6i_oDAiptXmRVnkr5EzwM,1348
 mapres/maps/time.py,sha256=TyncycYoIGVZWps32qWlFy2a2hTayvZWVHu9uh2nid8,2050
-mapres-3.dev6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-mapres-3.dev6.dist-info/METADATA,sha256=GnbMjkS5eTneybi5Uyhw_PB8svvp2qg7LjBP3yEipVw,1475
-mapres-3.dev6.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-mapres-3.dev6.dist-info/top_level.txt,sha256=5LMVQqJdtyjxfzv7wJBOZ-360m0Yc79w_-Y7s3n6cTw,7
-mapres-3.dev6.dist-info/RECORD,,
+mapres-3.dev8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+mapres-3.dev8.dist-info/METADATA,sha256=394wGpH8u6Ty7yMaxlW5HfTfky8_9W-wQ2NNNIRZ-dM,1475
+mapres-3.dev8.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mapres-3.dev8.dist-info/top_level.txt,sha256=5LMVQqJdtyjxfzv7wJBOZ-360m0Yc79w_-Y7s3n6cTw,7
+mapres-3.dev8.dist-info/RECORD,,