syncraft 0.1.11__tar.gz → 0.1.13__tar.gz

{syncraft-0.1.11 → syncraft-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.11
+Version: 0.1.13
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT

{syncraft-0.1.11 → syncraft-0.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "syncraft"
-version = "0.1.11"
+version = "0.1.13"
 description = "Parser combinator library"
 license = "MIT"
 license-files = ["LICENSE"]

{syncraft-0.1.11 → syncraft-0.1.13}/syncraft/algebra.py

@@ -28,7 +28,7 @@ from typing import (
 )
 
 import traceback
-from dataclasses import dataclass, fields, replace
+from dataclasses import dataclass, fields, replace, field
 from functools import cached_property
 from weakref import WeakKeyDictionary
 from abc import ABC, abstractmethod
@@ -54,15 +54,11 @@ class Insptectable(ABC):
 
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Result type for mapping
-C = TypeVar('C')  # Result type for composing lenses
+
 S = TypeVar('S')  # State type for the Algebra
 
     
     
-
-class StructuralResult:
-    pass    
-
 class FrozenDict(Generic[A]):
     def __init__(self, items: Mapping[str, A]):
         for k, v in items.items():
@@ -119,63 +115,41 @@ class Lens(Generic[S, A]):
     
     def __rtruediv__(self, other: Lens[B, S])->Lens[B, A]:
         return other.__truediv__(self)
-    
-    
+        
+class StructuralResult:
+    def bimap(self, ctx: Any)->Tuple[Any, Callable[[Any], StructuralResult]]:
+        return (self, lambda x: self)
 
-@dataclass(eq=True, frozen=True)
-class NamedResult(Generic[A, B], StructuralResult):
-    value: A
+        
+@dataclass(frozen=True)
+class NamedResult(Generic[A], StructuralResult):
     name: str
-    forward_map: Callable[[A], B] | None = None
-    backward_map: Callable[[B], A] | None = None
-    aggregator: Callable[..., Any] | None = None
-
-    def __post_init__(self)->None:
-        if (self.forward_map or self.backward_map) and self.aggregator is not None:
-            raise ValueError("NamedResult can have either bimap or aggregator, never both.")
-
-    @staticmethod
-    def lens() -> Lens[NamedResult[A, B], A]:
-        def get(data: NamedResult[A, B]) -> A:
-            return data.value
-
-        def set(data: NamedResult[A, B], value: A) -> NamedResult[A, B]:
-            return replace(data, value = value)
-
-        return Lens(get=get, set=set)
-    
-
+    value: A
+    def bimap(self, ctx: Any)->Tuple[NamedResult[Any], Callable[[NamedResult[Any]], StructuralResult]]:
+        value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
+        return NamedResult(self.name, value), lambda data: NamedResult(self.name, backward(data))
 
 @dataclass(eq=True, frozen=True)
 class ManyResult(Generic[A], StructuralResult):
     value: Tuple[A, ...]
+    def bimap(self, ctx: Any)->Tuple[List[Any], Callable[[List[Any]], StructuralResult]]:
+        transformed = [v.bimap(ctx) if isinstance(v, StructuralResult) else (v, lambda x: x) for v in self.value]
+        backmaps = [b for (_, b) in transformed]
+        ret = [a for (a, _) in transformed]
+        def backward(data: List[Any]) -> StructuralResult:
+            if len(data) != len(transformed):
+                raise ValueError("Incompatible data length")
+            return ManyResult(value=tuple([backmaps[i](x) for i, x in enumerate(data)]))
+        return ret, lambda data: backward(data)
 
-    @staticmethod
-    def lens(index: int) -> Lens[ManyResult[A], A]:
-        def get(data: ManyResult[A]) -> A:
-            return data.value[index]
-
-        def set(data: ManyResult[A], value: A) -> ManyResult[A]:
-            new_value = list(data.value)
-            new_value[index] = value
-            return ManyResult(value=tuple(new_value))
-
-        return Lens(get=get, set=set)
 
 
 @dataclass(eq=True, frozen=True)
 class OrResult(Generic[A], StructuralResult):
     value: A
-
-    @staticmethod
-    def lens() -> Lens[OrResult[A], A]:
-        def get(data: OrResult[A]) -> A:
-            return data.value
-
-        def set(data: OrResult[A], value: A) -> OrResult[A]:
-            return OrResult(value=value)
-
-        return Lens(get=get, set=set)
+    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
+        value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
+        return value, lambda data: OrResult(value=backward(data))
 
 
 class ThenKind(Enum):
@@ -188,89 +162,54 @@ class ThenResult(Generic[A, B], StructuralResult):
     kind: ThenKind
     left: A
     right: B
-    @cached_property
-    def flatten(self)-> Tuple[Any, ...]:
-        def _flatten_side(side: Any)->Tuple[Any, ...]:
-            return side.flatten if isinstance(side, ThenResult) else (side,)
+    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
+        def branch(b: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
+            if isinstance(b, ThenResult):
+               value, backward = b.bimap(ctx)
+               x, y = ThenResult.flat((value, backward))
+               return x, lambda data: ThenResult(self.kind, y(data), self.right)
+            elif isinstance(b, StructuralResult):
+                return b.bimap(ctx)
+            else:
+                return b, lambda x: x
         match self.kind:
             case ThenKind.BOTH:
-                return _flatten_side(self.left) + _flatten_side(self.right)
+                left_value, left_bmap = branch(self.left)
+                right_value, right_bmap = branch(self.right)
+                def backward(x: Tuple[Any, Any]) -> StructuralResult:
+                    return ThenResult(self.kind, left_bmap(x[0]), right_bmap(x[1]))
+                x, y = ThenResult.flat((left_value, right_value))
+                return x, lambda data: backward(y(data))
             case ThenKind.LEFT:
-                return _flatten_side(self.left)
+                left_value, left_bmap = branch(self.left)
+                return left_value, lambda data: ThenResult(self.kind, left_bmap(data), self.right)
             case ThenKind.RIGHT:
-                return _flatten_side(self.right)
-            
+                right_value, right_bmap = branch(self.right)
+                return right_value, lambda data: ThenResult(self.kind, self.left, right_bmap(data))
     @staticmethod
-    def lens(kind: ThenKind) -> Lens[ThenResult[A, B], Tuple[A, B]] | Lens[ThenResult[A, B], A] | Lens[ThenResult[A, B], B]:
-        def both_lens() -> Lens[ThenResult[A, B], Tuple[A, B]]:
-            def get(data: ThenResult[A, B]) -> Tuple[A, B]:
-                match data:
-                    case ThenResult(left=left, right=right, kind=ThenKind.BOTH):
-                        return left, right
-                    case _:
-                        raise ValueError(f"Unexpected ThenResult type: {type(data)}")
-
-            def set(data: ThenResult[A, B], value: Tuple[A, B] | ThenResult[A, B]) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(left=_, right=_, kind=ThenKind.BOTH):
-                        if isinstance(value, tuple) and len(value) == 2:
-                            return ThenResult(left=value[0], right=value[1], kind=ThenKind.BOTH)
-                        elif isinstance(value, ThenResult):
-                            return ThenResult(left=value.left, right=value.right, kind=ThenKind.BOTH)
-                        else:
-                            raise ValueError(f"Expected a tuple or ThenResult, got: {type(value)}")
-                    case _:
-                        raise ValueError(f"Unexpected ThenResult type: {type(data)}")
-            return Lens(get=get, set=set)
-
-        def left_lens()-> Lens[ThenResult[A, B], A]:
-            def left_get(data: ThenResult[A, B]) -> A:
-                match data:
-                    case ThenResult(left=left, right=_, kind=ThenKind.LEFT):
-                        return left
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-
-            def left_set(data: ThenResult[A, B], v: A) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(kind=ThenKind.LEFT):
-                        return replace(data, left=v)
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-                return 
-            return Lens(
-                get=left_get, 
-                set=left_set
-            )
-    
-        def right_lens()-> Lens[ThenResult[A, B], B]:
-            def right_get(data: ThenResult[A, B]) -> B:
-                match data:
-                    case ThenResult(left=_, right=right, kind=ThenKind.RIGHT):
-                        return right
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-
-            def right_set(data: ThenResult[A, B], v: B) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(kind=ThenKind.RIGHT):
-                        return replace(data, right=v)
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-                return
-            return Lens(
-                get=right_get,
-                set=right_set
-            )
-        match kind:
-            case ThenKind.BOTH:
-                return both_lens()
-            case ThenKind.LEFT:
-                return left_lens()
-            case ThenKind.RIGHT:
-                return right_lens()
-            case _:
-                raise ValueError(f"Unknown ThenKind: {kind}")
+    def flat(array: Tuple[Any, Any]) -> Tuple[Tuple[Any, ...], Callable[[Tuple[Any, ...]], Tuple[Any, Any]]]:
+        index: Dict[int, int] = {}
+        ret: List[Any] = []
+        for e in array:
+            if isinstance(e, tuple):
+                index[len(ret)] = len(e)
+                ret.extend(e)
+            else:
+                ret.append(e)
+        def backward(data: Tuple[Any, ...]) -> Tuple[Any, Any]:
+            tmp: List[Any] = []
+            skip: int = 0
+            for i, e in enumerate(data):
+                if skip <= 0:
+                    if i in index:
+                        tmp.append(tuple(data[i:i + index[i]]))
+                        skip = index[i] - 1
+                    else:
+                        tmp.append(e)
+                else:
+                    skip -= 1
+            return tuple(tmp)
+        return tuple(ret), backward
 
 
 InProgress = object()  # Marker for in-progress state, used to prevent re-entrance in recursive calls

syncraft-0.1.13/syncraft/ast.py

@@ -0,0 +1,125 @@
+
+
+from __future__ import annotations
+import re
+from typing import (
+    Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
+    Protocol, Generic, Callable, Union
+)
+from syncraft.algebra import (
+    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult,
+    Lens
+)
+from dataclasses import dataclass, replace, is_dataclass, asdict
+from enum import Enum
+from functools import cached_property
+
+@runtime_checkable
+class TokenProtocol(Protocol):
+    @property
+    def token_type(self) -> Enum: ...
+    @property
+    def text(self) -> str: ...
+    
+
+@dataclass(frozen=True)
+class Token:
+    token_type: Enum
+    text: str
+    def __str__(self) -> str:
+        return f"{self.token_type.name}({self.text})"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+@dataclass(frozen=True)
+class TokenSpec:
+    token_type: Optional[Enum] = None
+    text: Optional[str] = None
+    case_sensitive: bool = False
+    regex: Optional[re.Pattern[str]] = None
+        
+    def is_valid(self, token: TokenProtocol) -> bool:
+        type_match = self.token_type is None or token.token_type == self.token_type
+        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
+                                                    token.text.strip().upper() == self.text.strip().upper())
+        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
+        return type_match and value_match
+
+
+
+
+T = TypeVar('T', bound=TokenProtocol)  
+
+
+ParseResult = Union[
+    ThenResult['ParseResult[T]', 'ParseResult[T]'], 
+    NamedResult['ParseResult[T]'],
+    ManyResult['ParseResult[T]'],
+    OrResult['ParseResult[T]'],
+    T,
+]
+@dataclass(frozen=True)
+class AST(Generic[T]):
+    focus: ParseResult[T]
+    pruned: bool = False
+    parent: Optional[AST[T]] = None
+
+    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], AST[T]]]:
+        value, backward = self.focus.bimap(ctx) if isinstance(self.focus, StructuralResult) else (self.focus, lambda x: x)
+        def back2ast(data: Any) -> AST[T]:
+            return replace(self, focus=backward(data)) # type: ignore
+        return value, back2ast
+
+    def up(self)->Optional[AST[T]]:
+        return self.parent
+
+    def left(self) -> Optional[AST[T]]:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
+            case ThenResult(left=left, kind=kind):
+                return replace(self, focus=left, parent=self, pruned = self.pruned or kind == ThenKind.RIGHT)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for left traversal")
+
+    def right(self) -> Optional[AST[T]]:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
+            case ThenResult(right=right, kind=kind):
+                return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for right traversal")
+
+
+    def down(self, index: int) -> Optional[AST[T]]:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
+            case ManyResult(value=children):
+                if 0 <= index < len(children):
+                    return replace(self, focus=children[index], parent=self, pruned=self.pruned)
+                else:
+                    raise IndexError(f"Index {index} out of bounds for ManyResult with {len(children)} children")
+            case OrResult(value=value):
+                if index == 0:
+                    return replace(self, focus=value, parent=self, pruned=self.pruned)
+                else:
+                    raise IndexError(f"Index {index} out of bounds for OrResult")
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
+
+    def how_many(self)->int:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
+            case ManyResult(value=children):
+                return len(children)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for how_many")
+            
+    
+
+    @cached_property
+    def root(self) -> AST[T]:
+        while self.parent is not None:
+            self = self.parent  
+        return self
+    

{syncraft-0.1.11 → syncraft-0.1.13}/syncraft/dsl.py

@@ -6,7 +6,7 @@ from typing import (
 )
 from dataclasses import dataclass, field
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, Insptectable, NamedResult, ThenResult, ManyResult, ThenKind
+from syncraft.algebra import Algebra, Error, Either, Insptectable, ThenResult, ManyResult, ThenKind
 from types import MethodType, FunctionType
 
 

{syncraft-0.1.11 → syncraft-0.1.13}/syncraft/generator.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from typing import (
-    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, Iterable, Hashable, 
-    cast, List
+    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, Iterable, 
+    List
 )
 from functools import cached_property
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
     Algebra, ThenResult, Either, Left, Right, Error, Insptectable, 
-    NamedResult, OrResult, ManyResult, ThenKind
+    OrResult, ManyResult
 )
 from syncraft.ast import TokenProtocol, ParseResult, AST, Token, TokenSpec
 from sqlglot import TokenType
@@ -142,7 +142,8 @@ class TokenGen(TokenSpec):
 class Generator(Algebra[GenResult[T], GenState[T]]):  
     def flat_map(self, f: Callable[[GenResult[T]], Algebra[B, GenState[T]]]) -> Algebra[B, GenState[T]]: 
         def flat_map_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
-            match self.run(input.left(), use_cache=use_cache):
+            lft = input.left()
+            match self.run(lft, use_cache=use_cache):
                 case Left(error):
                     return Left(error)
                 case Right((value, next_input)):
@@ -175,8 +176,20 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                     match self.run(input.down(index), use_cache):
                         case Right((value, next_input)):
                             ret.append(value)
+                            if at_most is not None and len(ret) > at_most:
+                                return Left(Error(
+                                        message=f"Expected at most {at_most} matches, got {len(ret)}",
+                                        this=self,
+                                        state=input.down(index)
+                                    ))                             
                         case Left(_):
                             pass
+                if len(ret) < at_least:
+                    return Left(Error(
+                        message=f"Expected at least {at_least} matches, got {len(ret)}",
+                        this=self,
+                        state=input.down(index)
+                    )) 
                 return Right((ManyResult(tuple(ret)), input))
         return self.__class__(many_run, name=f"many({self.name})")  # type: ignore
     
@@ -203,7 +216,7 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                             case Left(error):
                                 return Left(error)
             raise ValueError("or_else should always return a value or an error.")
-        return self.__class__(or_else_run, name=f"free_or({self.name} | {other.name})") # type: ignore
+        return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})") # type: ignore
 
     @classmethod
     def token(cls, 

{syncraft-0.1.11 → syncraft-0.1.13}/syncraft/parser.py

@@ -111,52 +111,79 @@ class Parser(Algebra[Tuple[T,...] | T, ParserState[T]]):
               inclusive: bool = True, 
               strict: bool = True) -> Algebra[Any, ParserState[T]]:
         def until_run(state: ParserState[T], use_cache:bool) -> Either[Any, Tuple[Any, ParserState[T]]]:
-            counters = [0] * len(open_close)
+            # Use a stack to enforce proper nesting across multiple open/close pairs.
             tokens: List[Any] = []
             if not terminator and len(open_close) == 0:
-                return Left(Error(this=until_run, message="No terminator and no open/close parsers, nothing to parse", state=state))  
-            def run_oc(s: ParserState[T], 
-                       sign: int, 
-                       *oc: Algebra[Any, ParserState[T]])->Tuple[bool, ParserState[T]]:
-                matched = False
-                for i, p in enumerate(oc):
-                    new = p.run(s, use_cache)
-                    if isinstance(new, Right):
-                        matched = True
-                        counters[i] += sign
-                        if inclusive:
-                            tokens.append(new.value[0])
-                        s = new.value[1]
-                return matched, s
+                return Left(Error(this=until_run, message="No terminator and no open/close parsers, nothing to parse", state=state))
+
+            # Helper to try matching any of the parsers once, returning early on first match
+            def try_match(s: ParserState[T], *parsers: Algebra[Any, ParserState[T]]) -> Tuple[bool, Optional[int], Optional[Any], ParserState[T]]:
+                for i, p in enumerate(parsers):
+                    res = p.run(s, use_cache)
+                    if isinstance(res, Right):
+                        val, ns = res.value
+                        return True, i, val, ns
+                return False, None, None, s
+
             opens, closes = zip(*open_close) if len(open_close) > 0 else ((), ())
             tmp_state: ParserState[T] = state.copy()
-            if strict:
-                c = reduce(lambda a, b: a.or_else(b), opens).run(tmp_state)
+            stack: List[int] = []  # indices into open_close indicating expected closer
+
+            # If strict, require the very next token to be an opener of any kind
+            if strict and len(opens) > 0:
+                c = reduce(lambda a, b: a.or_else(b), opens).run(tmp_state, use_cache)
                 if c.is_left():
-                    return Left(Error(
-                        this=until_run,
-                        message="No opening parser matched",
-                        state=tmp_state
-                    ))
+                    return Left(Error(this=until_run, message="No opening parser matched", state=tmp_state))
+
             while not tmp_state.ended():
-                mopen, tmp_state = run_oc(tmp_state, 1, *opens)
-                mclose, tmp_state = run_oc(tmp_state, -1, *closes)
-                matched = mopen or mclose
-                if all(c == 0 for c in counters):
-                    if terminator :
-                        new = terminator.run(tmp_state, use_cache)
-                        if isinstance(new, Right):
-                            matched = True
+                # Try to open
+                o_matched, o_idx, o_tok, o_state = try_match(tmp_state, *opens)
+                if o_matched and o_idx is not None:
+                    stack.append(o_idx)
+                    if inclusive:
+                        tokens.append(o_tok)
+                    tmp_state = o_state
+                    continue
+
+                # Try to close
+                c_matched, c_idx, c_tok, c_state = try_match(tmp_state, *closes)
+                if c_matched and c_idx is not None:
+                    if not stack or stack[-1] != c_idx:
+                        return Left(Error(this=until_run, message="Mismatched closing parser", state=tmp_state))
+                    stack.pop()
+                    if inclusive:
+                        tokens.append(c_tok)
+                    tmp_state = c_state
+                    # After closing, if stack empty, we may terminate on a terminator
+                    if len(stack) == 0:
+                        if terminator:
+                            term = terminator.run(tmp_state, use_cache)
+                            if isinstance(term, Right):
+                                if inclusive:
+                                    tokens.append(term.value[0])
+                                return Right((tuple(tokens), term.value[1]))
+                        else:
+                            return Right((tuple(tokens), tmp_state))
+                    continue
+
+                # If nothing structural matched, check termination when not nested
+                if len(stack) == 0:
+                    if terminator:
+                        term2 = terminator.run(tmp_state, use_cache)
+                        if isinstance(term2, Right):
                             if inclusive:
-                                tokens.append(new.value[0])
-                            return Right((tuple(tokens), new.value[1]))
+                                tokens.append(term2.value[0])
+                            return Right((tuple(tokens), term2.value[1]))
                     else:
                         return Right((tuple(tokens), tmp_state))
-                elif any(c < 0 for c in counters):
-                    return Left(Error(this=until_run, message="Unmatched closing parser", state=tmp_state))
-                if not matched:
-                    tokens.append(tmp_state.current())
-                    tmp_state = tmp_state.advance()
+
+                # Otherwise, consume one token as payload and continue
+                tokens.append(tmp_state.current())
+                tmp_state = tmp_state.advance()
+
+            # Reached end of input
+            if len(stack) != 0:
+                return Left(Error(this=until_run, message="Unterminated group", state=tmp_state))
             return Right((tuple(tokens), tmp_state))
         return cls(until_run, name=cls.__name__ + '.until')
 

{syncraft-0.1.11 → syncraft-0.1.13}/syncraft.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.11
+Version: 0.1.13
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT

{syncraft-0.1.11 → syncraft-0.1.13}/syncraft.egg-info/SOURCES.txt

@@ -16,4 +16,5 @@ syncraft.egg-info/SOURCES.txt
 syncraft.egg-info/dependency_links.txt
 syncraft.egg-info/requires.txt
 syncraft.egg-info/top_level.txt
-tests/test_parse.py
+tests/test_parse.py
+tests/test_until.py

{syncraft-0.1.11 → syncraft-0.1.13}/tests/test_parse.py

@@ -1,7 +1,6 @@
 from syncraft.parser import AST, literal, variable, parse, Parser
 import syncraft.generator as gen
 from typing import Any
-from rich import print
 
 IF = literal("if")
 ELSE = literal("else")
@@ -32,5 +31,5 @@ def test_many_or()->None:
     syntax = (IF.many() | THEN.many()).many() // END
     sql = "if if then end"
     ast:AST[Any] = parse(syntax(Parser), sql, dialect='sqlite')
-    generated = gen.generate(syntax(gen.Generator))
-    # assert ast == generated, "Parsed and generated results do not match."
+    generated = gen.generate(syntax(gen.Generator), ast)
+    assert ast == generated, "Parsed and generated results do not match."

syncraft-0.1.13/tests/test_until.py

@@ -0,0 +1,40 @@
+from typing import Any
+from syncraft.parser import parse, until, literal, Parser
+from syncraft.ast import AST
+
+# Define common pair DSLs
+LP, RP = literal("("), literal(")")
+LB, RB = literal("["), literal("]")
+
+
+def test_until_accepts_proper_nesting() -> None:
+    sql = "([])"
+    syntax = until((LP, RP), (LB, RB))
+    ast: AST[Any] | Any = parse(syntax(Parser), sql, dialect="sqlite")
+    assert isinstance(ast, AST), f"Expected AST for proper nesting, got {ast}"
+
+
+def test_until_rejects_mismatched_pairs() -> None:
+    # Mismatched: ( ] should fail immediately
+    sql = "(]"
+    syntax = until((LP, RP), (LB, RB))
+    res = parse(syntax(Parser), sql, dialect="sqlite")
+    from syncraft.algebra import Error
+    assert isinstance(res, Error), "Mismatched pairs should be rejected with an Error"
+
+def test_until_rejects_unterminated_group() -> None:
+    # Unterminated: ( ... EOF
+    sql = "("
+    syntax = until((LP, RP))
+    res = parse(syntax(Parser), sql, dialect="sqlite")
+    from syncraft.algebra import Error
+    assert isinstance(res, Error), "Unterminated group should be rejected with an Error"
+
+def test_until_rejects_crossing_pairs() -> None:
+    # Crossing/interleaved: ([)] should be rejected
+    sql = "([)]"
+    syntax = until((LP, RP), (LB, RB))
+    # Use postgres dialect so [ and ] are tokenized distinctly (not as bracketed identifier)
+    res = parse(syntax(Parser), sql, dialect="postgres")
+    from syncraft.algebra import Error
+    assert isinstance(res, Error), "Crossing pairs should be rejected with an Error"

syncraft-0.1.11/syncraft/ast.py

@@ -1,202 +0,0 @@
-
-
-from __future__ import annotations
-import re
-from typing import (
-    Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
-    Protocol, Generic, Callable, Union
-)
-from syncraft.algebra import (
-    NamedResult, OrResult,ThenResult, ManyResult, ThenKind,
-    Lens
-)
-from dataclasses import dataclass, field, replace, is_dataclass, asdict
-from enum import Enum
-from functools import cached_property
-
-@runtime_checkable
-class TokenProtocol(Protocol):
-    @property
-    def token_type(self) -> Enum: ...
-    @property
-    def text(self) -> str: ...
-    
-
-@dataclass(frozen=True)
-class Token:
-    token_type: Enum
-    text: str
-    def __str__(self) -> str:
-        return f"{self.token_type.name}({self.text})"
-    
-    def __repr__(self) -> str:
-        return self.__str__()
-
-@dataclass(frozen=True)
-class TokenSpec:
-    token_type: Optional[Enum] = None
-    text: Optional[str] = None
-    case_sensitive: bool = False
-    regex: Optional[re.Pattern[str]] = None
-        
-    def is_valid(self, token: TokenProtocol) -> bool:
-        type_match = self.token_type is None or token.token_type == self.token_type
-        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
-                                                    token.text.strip().upper() == self.text.strip().upper())
-        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
-        return type_match and value_match
-
-
-
-
-T = TypeVar('T', bound=TokenProtocol)  
-
-
-ParseResult = Union[
-    ThenResult['ParseResult[T]', 'ParseResult[T]'], 
-    NamedResult['ParseResult[T]', Any], 
-    ManyResult['ParseResult[T]'],
-    OrResult['ParseResult[T]'],
-    Tuple[T, ...],
-    T,
-] 
-
-
-
-
-    
-
-
-@dataclass(frozen=True)
-class NamedRecord:
-    lens: Lens[Any, Any]
-    value: Any
-
-@dataclass(frozen=True)
-class Walker:
-    lens: Optional[Lens[Any, Any]] = None
-    def get(self, root: ParseResult[Any]) -> Dict[str, NamedRecord]:
-        match root:
-            case ManyResult(value=children):
-                new_named: Dict[str, NamedRecord] = {}
-                for i, child in enumerate(children):
-                    new_walker = replace(self, lens=(self.lens / ManyResult.lens(i)) if self.lens else ManyResult.lens(i))
-                    new_named |= new_walker.get(child)
-                return new_named
-            case OrResult(value=value):
-                new_walker = replace(self, lens=(self.lens / OrResult.lens()) if self.lens else OrResult.lens())
-                return new_walker.get(value)
-            case ThenResult(left=left, 
-                            right=right, 
-                            kind=kind):
-                new_walker = replace(self, lens=(self.lens / ThenResult.lens(kind)) if self.lens else ThenResult.lens(kind))
-                return new_walker.get(left) | new_walker.get(right)
-            case NamedResult(name=name, 
-                             value=value, 
-                             forward_map=forward_map,
-                             backward_map=backward_map,
-                             aggregator=aggregator):
-                this_lens = (self.lens / NamedResult.lens()) if self.lens else NamedResult.lens()
-                if callable(forward_map) and callable(backward_map):
-                    this_lens = this_lens.bimap(forward_map, backward_map) 
-                elif callable(forward_map):
-                    this_lens = this_lens.bimap(forward_map, lambda _: value)
-                elif callable(backward_map):
-                    raise ValueError("backward_map provided without forward_map")
-                new_walker = replace(self, lens=this_lens)
-                child_named = new_walker.get(value)
-                if aggregator is not None:
-                    return child_named | {name: NamedRecord(lens=this_lens, 
-                                                            value=aggregator(child_named))}
-                else:
-                    return child_named
-        return {}
-
-    def set(self, root: ParseResult[Any], updated_values: Dict[str, Any]) -> ParseResult[Any]:
-        named_records = self.get(root)
-        def apply_update(name: str, value: Any, root: ParseResult[Any]) -> ParseResult[Any]:
-            if name not in named_records:
-                # Skip unknown names safely
-                return root
-            record = named_records[name]
-            target_named: NamedResult[Any, Any] = record.lens.get(root)
-            assert isinstance(target_named, NamedResult)
-
-            if target_named.aggregator is not None:
-                # Break apart dataclass/dict into child fields
-                if isinstance(value, dict):
-                    child_updates = value
-                elif is_dataclass(value) and not isinstance(value, type):
-                    child_updates = asdict(value)
-                else:
-                    raise TypeError(f"Unsupported aggregator value for '{name}': {type(value)}")
-
-                # Recursively apply each child update
-                for child_name, child_value in child_updates.items():
-                    root = apply_update(child_name, child_value, root)
-                return root
-
-            else:
-                # Leaf: just replace the value
-                updated_named = replace(target_named, value=value)
-                return record.lens.set(root, updated_named)
-
-        for name, value in updated_values.items():
-            root = apply_update(name, value, root)
-
-        return root
-
-@dataclass(frozen=True)
-class AST(Generic[T]):
-    focus: ParseResult[T]
-    pruned: bool = False
-    parent: Optional[AST[T]] = None
-
-    def up(self)->Optional[AST[T]]:
-        return self.parent
-
-    def left(self) -> Optional[AST[T]]:
-        match self.focus:
-            case ThenResult(left=left, kind=kind):
-                return replace(self, focus=left, parent=self, pruned = self.pruned or kind == ThenKind.RIGHT)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for left traversal")
-
-    def right(self) -> Optional[AST[T]]:
-        match self.focus:
-            case ThenResult(right=right, kind=kind):
-                return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for right traversal")
-
-
-    def down(self, index: int) -> Optional[AST[T]]:
-        match self.focus:
-            case ManyResult(value=children):
-                if 0 <= index < len(children):
-                    return replace(self, focus=children[index], parent=self, pruned=self.pruned)
-                else:
-                    raise IndexError(f"Index {index} out of bounds for ManyResult with {len(children)} children")
-            case OrResult(value=value):
-                if index == 0:
-                    return replace(self, focus=value, parent=self, pruned=self.pruned)
-                else:
-                    raise IndexError(f"Index {index} out of bounds for OrResult")
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
-
-    def how_many(self)->int:
-        match self.focus:
-            case ManyResult(value=children):
-                return len(children)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for how_many")
-            
-    
-
-    @cached_property
-    def root(self) -> AST[T]:
-        while self.parent is not None:
-            self = self.parent  
-        return self
-