mapres 3.dev20__tar.gz → 3.dev22__tar.gz

{mapres-3.dev20/src/mapres.egg-info → mapres-3.dev22}/PKG-INFO

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

{mapres-3.dev20 → mapres-3.dev22}/pyproject.toml

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

{mapres-3.dev20 → mapres-3.dev22}/src/mapres/datamap.py

@@ -1,4 +1,3 @@
-import re
 from dataclasses import dataclass, fields, is_dataclass
 
 # syntax identifiers
@@ -30,15 +29,13 @@ class DataMap:
 
     Mode metadata (__mode__) controls behavior:
         - None: plain static map
-        - "dynamic": values may be provided by callables/providers
-        - "config": config-style maps (no dynamic evaluation)
-        - "callable": map exposes callable methods for nested calls
+        - 'dynamic': values may be provided by callables/providers
+        - 'config': config-style maps (no dynamic evaluation)
+        - 'callable': map exposes callable methods for nested calls
     '''
     __syntax__: str = None
-    __mode__: str | None = None # "dynamic", "config", "callable", or None
-    __recursive__: bool = False
+    __mode__: str | None = None  # 'dynamic', 'config', 'callable', or None
     __missing_key__: str = 'error'  # 'error', 'silent', 'placeholder'
-    __ignore_delimiters__: bool = False
 
     def as_map(self):
         '''
@@ -95,14 +92,11 @@ class DataMap:
         return out
 
 
-def datamap(_cls=None, *, syntax=None, mode=None, recursive=None, missing_key=None, ignore_delimiters=None):
-
+def datamap(_cls=None, *, syntax=None, mode=None, missing_key=None):
     def wrap(cls):
         cls.__syntax__ = syntax
         cls.__mode__ = mode
-        cls.__recursive__ = recursive
         cls.__missing_key__ = missing_key or 'error'
-        cls.__ignore_delimiters__ = ignore_delimiters or False
 
         namespace = dict(cls.__dict__)
         namespace['__dict__'] = {}

mapres-3.dev22/src/mapres/evaluator.py

@@ -0,0 +1,123 @@
+from .ast import TemplateNode, TextNode, IdentNode, CallNode
+from .tokenizer import Tokenizer
+from .parser import Parser
+from .exceptions import MapResError, MissingKeyError
+
+
+class EvaluationError(MapResError):
+    pass
+
+
+class Evaluator:
+    def __init__(self, layerstack, ctx=None):
+        self.layerstack = layerstack
+        self.ctx = ctx or {}
+        self._seen = set()  # cycle detection
+
+    # public api
+    def evaluate(self, node):
+        return self._eval(node)
+
+    # internal dispatch
+    def _eval(self, node):
+        if isinstance(node, TemplateNode):
+            return self._eval_template(node)
+
+        if isinstance(node, TextNode):
+            return node.text
+
+        if isinstance(node, IdentNode):
+            return self._eval_ident(node)
+
+        if isinstance(node, CallNode):
+            return self._eval_call(node)
+
+        raise EvaluationError(f'Unknown AST node: {node}')
+
+    # template
+    def _eval_template(self, node: TemplateNode):
+        parts = []
+        for child in node.children:
+            parts.append(self._eval(child))
+        out = ''.join(parts)
+        return out
+
+    # identifier
+    def _eval_ident(self, node: IdentNode):
+        name = node.name
+
+        # cycle detection
+        if name in self._seen:
+            raise EvaluationError(f"Cycle detected in identifier '{name}'")
+        self._seen.add(name)
+
+        parts = name.split('.')
+
+        # 1. ctx first
+        val = self._lookup_hierarchical(self.ctx, parts)
+        if val is not None:
+            self._seen.remove(name)
+            return str(val)
+
+        # 2. syntax-bound maps
+        for m in self.layerstack.all_maps():
+            if getattr(m, '__syntax__', None) not in (None, node.syntax):
+                continue
+
+            d = self._map_to_dict(m)
+            val = self._lookup_hierarchical(d, parts)
+            if val is not None:
+                self._seen.remove(name)
+                return str(val)
+
+        self._seen.remove(name)
+        raise MissingKeyError(name)
+
+    # call (nested token)
+    def _eval_call(self, node: CallNode):
+        outer = node.name
+
+        if outer in self._seen:
+            raise EvaluationError(f"Cycle detected in call '{outer}'")
+        self._seen.add(outer)
+
+        arg_value = self._eval(node.arg)
+        parts = [outer, arg_value]
+
+        # ctx first
+        val = self._lookup_hierarchical(self.ctx, parts)
+        if val is not None:
+            self._seen.remove(outer)
+            return str(val)
+
+        # syntax-bound maps
+        for m in self.layerstack.all_maps():
+            if getattr(m, '__syntax__', None) not in (None, node.syntax):
+                continue
+
+            d = self._map_to_dict(m)
+            val = self._lookup_hierarchical(d, parts)
+            if val is not None:
+                self._seen.remove(outer)
+                return str(val)
+
+        self._seen.remove(outer)
+        raise MissingKeyError(f'{outer}({arg_value})')
+
+    # helpers
+    def _map_to_dict(self, m):
+        if hasattr(m, 'as_map'):
+            return m.as_map()
+        if isinstance(m, dict):
+            return m
+        raise EvaluationError(f'Invalid map object: {m}')
+
+    def _lookup_hierarchical(self, root, parts):
+        cur = root
+        for p in parts:
+            if not isinstance(cur, dict):
+                return None
+            if p not in cur:
+                return None
+            cur = cur[p]
+        return cur

{mapres-3.dev20 → mapres-3.dev22}/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.dev20 → mapres-3.dev22}/src/mapres/tokenizer.py

@@ -33,37 +33,29 @@ class Token:
 
 
 class Tokenizer:
-    def __init__(self, text):
+    def __init__(self, text: str):
         self.text = text
         self.i = 0
         self.n = len(text)
-        self.tokens = []
+        self.tokens: list[Token] = []
 
-        # 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):
+    def peek(self, k: int = 0) -> str:
         idx = self.i + k
         if idx >= self.n:
             return ''
         return self.text[idx]
 
-    def advance(self, k=1):
+    def advance(self, k: int = 1) -> None:
         self.i += k
 
-    def match(self, s):
+    def match(self, s: str) -> bool:
         return self.text.startswith(s, self.i)
 
-    def emit(self, type_, value=None):
+    def emit(self, type_, value=None) -> None:
         self.tokens.append(Token(type_, value, self.i))
 
-    def tokenize(self):
-        buf = []
+    def tokenize(self) -> list[Token]:
+        buf: list[str] = []
 
         def flush_text():
             if buf:
@@ -95,93 +87,109 @@ class Tokenizer:
             if self.match(r'\)'):
                 buf.append(')'); self.advance(2); continue
 
-            # --- paired delimiters ---
-
-            # braces {{ }}
+            # --- {{IDENT}} ---
             if self.match('{{'):
                 flush_text()
-                self.emit(TokenType.BRACE_OPEN)
-                self.advance(2)
-                continue
-
-            if self.match('}}'):
-                flush_text()
-                self.emit(TokenType.BRACE_CLOSE)
+                start = self.i
                 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)
+                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
 
-            # --- mixed delimiters (dollars) ---
-
+            # --- ${IDENT} ---
             if self.match('${'):
                 flush_text()
-                self.emit(TokenType.DOLLAR_OPEN)
-                self.in_dollar = True
+                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
 
-            if ch == '}':
+            # --- <IDENT> ---
+            if ch == '<':
                 flush_text()
-                if self.in_dollar:
-                    self.emit(TokenType.DOLLAR_CLOSE)
-                    self.in_dollar = False
-                else:
-                    buf.append('}')
+                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
 
-            # --- toggle delimiters ---
-
-            # pipes |...|
-            if self.match('|'):
+            # --- |IDENT| ---
+            if ch == '|':
                 flush_text()
-                if not self.in_pipe:
+                start = self.i
+                self.advance()
+                ident = self._read_ident()
+                if ident is not None and self.peek() == '|':
                     self.emit(TokenType.PIPE_OPEN)
-                    self.in_pipe = True
-                else:
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
                     self.emit(TokenType.PIPE_CLOSE)
-                    self.in_pipe = False
+                    continue
+                self.i = start
+                buf.append(self.peek())
                 self.advance()
                 continue
 
-            # percents %...%
-            if self.match('%'):
+            # --- %IDENT% ---
+            if ch == '%':
                 flush_text()
-                if not self.in_percent:
+                start = self.i
+                self.advance()
+                ident = self._read_ident()
+                if ident is not None and self.peek() == '%':
                     self.emit(TokenType.PERCENT_OPEN)
-                    self.in_percent = True
-                else:
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
                     self.emit(TokenType.PERCENT_CLOSE)
-                    self.in_percent = False
+                    continue
+                self.i = start
+                buf.append(self.peek())
                 self.advance()
                 continue
 
-            # colons :...:
-            if self.match(':'):
+            # --- :IDENT: ---
+            if ch == ':':
                 flush_text()
-                if not self.in_colon:
+                start = self.i
+                self.advance()
+                ident = self._read_ident()
+                if ident is not None and self.peek() == ':':
                     self.emit(TokenType.COLON_OPEN)
-                    self.in_colon = True
-                else:
+                    self.emit(TokenType.IDENT, ident)
+                    self.advance()
                     self.emit(TokenType.COLON_CLOSE)
-                    self.in_colon = False
+                    continue
+                self.i = start
+                buf.append(self.peek())
                 self.advance()
                 continue
 
             # --- parens ---
-
             if ch == '(':
                 flush_text()
                 self.emit(TokenType.LPAREN)
@@ -194,39 +202,30 @@ class Tokenizer:
                 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 ---
-
+            # 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.dev20 → mapres-3.dev22/src/mapres.egg-info}/PKG-INFO

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

mapres-3.dev20/src/mapres/evaluator.py

@@ -1,221 +0,0 @@
-from .ast import TemplateNode, TextNode, IdentNode, CallNode
-from .tokenizer import Tokenizer
-from .parser import Parser
-from .exceptions import MapResError, MissingKeyError
-
-
-class EvaluationError(MapResError):
-    pass
-
-
-class Evaluator:
-    def __init__(self, layerstack, ctx=None):
-        self.layerstack = layerstack
-        self.ctx = ctx or {}
-        self._seen = set()  # cycle detection
-
-    # public api
-    def evaluate(self, node):
-        return self._eval(node)
-
-    # internal dispatch
-    def _eval(self, node):
-        if isinstance(node, TemplateNode):
-            return self._eval_template(node)
-
-        if isinstance(node, TextNode):
-            return node.text
-
-        if isinstance(node, IdentNode):
-            return self._eval_ident(node)
-
-        if isinstance(node, CallNode):
-            return self._eval_call(node)
-
-        raise EvaluationError(f'Unknown AST node: {node}')
-
-    # template
-    def _eval_template(self, node: TemplateNode):
-        parts = []
-        for child in node.children:
-            parts.append(self._eval(child))
-        out = ''.join(parts)
-
-        # recursion over full template output
-        if self._has_recursive_maps():
-            seen = set()
-            depth = 0
-            max_depth = self._get_max_depth()
-
-            while depth < max_depth:
-                new_out = self._re_resolve(out)
-                if new_out == out:
-                    break
-                if new_out in seen:
-                    raise EvaluationError('Cycle detected in template recursion')
-                seen.add(new_out)
-                out = new_out
-                depth += 1
-
-        return out
-
-    # identifier
-    def _eval_ident(self, node: IdentNode):
-        name = node.name
-
-        # ignore_delimiters: treat token as literal for this syntax
-        if self._syntax_ignores_delimiters(node.syntax):
-            return self._literal_from_syntax(name, node.syntax)
-
-        # cycle detection
-        if name in self._seen:
-            raise EvaluationError(f"Cycle detected in identifier '{name}'")
-        self._seen.add(name)
-
-        parts = name.split('.')
-
-        # 1. ctx first
-        val = self._lookup_hierarchical(self.ctx, parts)
-        if val is not None:
-            self._seen.remove(name)
-            return str(val)
-
-        # 2. syntax-bound maps
-        for m in self.layerstack.all_maps():
-            if getattr(m, '__syntax__', None) not in (None, node.syntax):
-                continue
-
-            d = self._map_to_dict(m)
-            val = self._lookup_hierarchical(d, parts)
-            if val is not None:
-                self._seen.remove(name)
-                return str(val)
-
-        self._seen.remove(name)
-        raise MissingKeyError(name)
-
-    # call (nested token)
-    def _eval_call(self, node: CallNode):
-        outer = node.name
-
-        # ignore_delimiters: treat call token as literal
-        if self._syntax_ignores_delimiters(node.syntax):
-            arg_text = self._eval(node.arg)
-            return self._literal_from_syntax(outer, node.syntax, is_call=True, arg_text=arg_text)
-
-        if outer in self._seen:
-            raise EvaluationError(f"Cycle detected in call '{outer}'")
-        self._seen.add(outer)
-
-        arg_value = self._eval(node.arg)
-        parts = [outer, arg_value]
-
-        # ctx first
-        val = self._lookup_hierarchical(self.ctx, parts)
-        if val is not None:
-            self._seen.remove(outer)
-            return str(val)
-
-        # syntax-bound maps
-        for m in self.layerstack.all_maps():
-            if getattr(m, '__syntax__', None) not in (None, node.syntax):
-                continue
-
-            d = self._map_to_dict(m)
-            val = self._lookup_hierarchical(d, parts)
-            if val is not None:
-                self._seen.remove(outer)
-                return str(val)
-
-        self._seen.remove(outer)
-        raise MissingKeyError(f'{outer}({arg_value})')
-
-    # helpers
-    def _map_to_dict(self, m):
-        if hasattr(m, 'as_map'):
-            return m.as_map()
-        if isinstance(m, dict):
-            return m
-        raise EvaluationError(f'Invalid map object: {m}')
-
-    def _lookup_hierarchical(self, root, parts):
-        cur = root
-        for p in parts:
-            if not isinstance(cur, dict):
-                return None
-            if p not in cur:
-                return None
-            cur = cur[p]
-        return cur
-
-    def _has_recursive_maps(self):
-        for m in self.layerstack.all_maps():
-            if getattr(m, '__recursive__', False) is True:
-                return True
-        return False
-
-    def _get_max_depth(self):
-        depths = [
-            getattr(m, '__max_depth__', 10)
-            for m in self.layerstack.all_maps()
-            if getattr(m, '__recursive__', False) is True
-        ]
-        return max(depths) if depths else 0
-
-    def _re_resolve(self, text: str) -> str:
-        tokens = Tokenizer(text).tokenize()
-        ast = Parser(tokens).parse()
-        return self.evaluate(ast)
-
-    def _syntax_ignores_delimiters(self, syntax_name: str) -> bool:
-        for m in self.layerstack.all_maps():
-            if getattr(m, '__syntax__', None) == syntax_name:
-                if getattr(m, '__ignore_delimiters__', False):
-                    return True
-        return False
-
-    def _literal_from_syntax(self, name: str, syntax_name: str, is_call: bool = False, arg_text: str | None = None) -> str:
-        if not is_call:
-            if syntax_name == 'colons':
-                return f':{name}:'
-            if syntax_name == 'braces':
-                return f'{{{{{name}}}}}'
-            if syntax_name == 'dollars':
-                return f'${{{name}}}'
-            if syntax_name == 'angles':
-                return f'<{name}>'
-            if syntax_name == 'pipes':
-                return f'|{name}|'
-            if syntax_name == 'percents':
-                return f'%{name}%'
-            if syntax_name == 'paren_dollars':
-                return f'$({name})'
-            if syntax_name == 'at_tags':
-                return f'@{name}@'
-            if syntax_name == 'hash_tags':
-                return f'#{name}#'
-            return name
-
-        # call literal: syntax-specific wrapping of name(arg_text)
-        arg = arg_text or ''
-        inner = f'{name}({arg})'
-
-        if syntax_name == 'colons':
-            return f':{inner}:'
-        if syntax_name == 'braces':
-            return f'{{{{{inner}}}}}'
-        if syntax_name == 'dollars':
-            return f'${{{inner}}}'
-        if syntax_name == 'angles':
-            return f'<{inner}>'
-        if syntax_name == 'pipes':
-            return f'|{inner}|'
-        if syntax_name == 'percents':
-            return f'%{inner}%'
-        if syntax_name == 'paren_dollars':
-            return f'$({inner})'
-        if syntax_name == 'at_tags':
-            return f'@{inner}@'
-        if syntax_name == 'hash_tags':
-            return f'#{inner}#'
-        return inner