syncraft 0.1.16__tar.gz → 0.1.18__tar.gz

{syncraft-0.1.16 → syncraft-0.1.18}/PKG-INFO

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

{syncraft-0.1.16 → syncraft-0.1.18}/pyproject.toml

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

{syncraft-0.1.16 → syncraft-0.1.18}/syncraft/ast.py

@@ -32,6 +32,8 @@ class Token:
     def __repr__(self) -> str:
         return self.__str__()
 
+    
+
 @dataclass(frozen=True)
 class TokenSpec:
     token_type: Optional[Enum] = None

{syncraft-0.1.16 → syncraft-0.1.18}/syncraft/generator.py

@@ -111,6 +111,7 @@ def token_type_from_string(token_type: Optional[TokenType], text: str, case_sens
 
 @dataclass(frozen=True)
 class TokenGen(TokenSpec):
+
     def __str__(self) -> str:
         tt = self.token_type.name if self.token_type else ""
         txt = self.text if self.text else ""
@@ -141,7 +142,9 @@ class TokenGen(TokenSpec):
                                                         self.case_sensitive), 
                      text=text)        
 
-
+    @staticmethod
+    def from_string(string: str)->Token:
+        return Token(token_type=token_type_from_string(None, string, case_sensitive=False), text=string)
 
 
 @dataclass(frozen=True)

{syncraft-0.1.16 → syncraft-0.1.18}/syncraft.egg-info/PKG-INFO

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

{syncraft-0.1.16 → syncraft-0.1.18}/tests/test_bimap.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
-from syncraft.algebra import NamedResult
+from syncraft.algebra import NamedResult, Error, ManyResult, OrResult, ThenResult, ThenKind
 from syncraft.parser import literal, parse, Parser
 import syncraft.generator as gen
+from syncraft.generator import TokenGen
 from rich import print
 
 
@@ -164,3 +165,109 @@ def test_deep_mix():
     assert ast == generated
     value, bmap = ast.bimap(None)
     assert bmap(value) == ast
+
+
+def test_empty_many() -> None:
+    A = literal("a")
+    syntax = A.many()  # This should allow empty matches
+    sql = ""
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    assert isinstance(ast, Error)
+
+
+def test_backtracking_many() -> None:
+    A = literal("a")
+    B = literal("b")
+    syntax = (A.many() + B)  # must not eat the final "a" needed for B
+    sql = "a a a a b"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    value, bmap = ast.bimap(None)
+    assert value[-1] == TokenGen.from_string("b")
+
+def test_deep_nesting() -> None:
+    A = literal("a")
+    syntax = A
+    for _ in range(100):
+        syntax = syntax + A
+    sql = " " .join("a" for _ in range(101))
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    assert ast is not None
+
+
+def test_nested_many() -> None:
+    A = literal("a")
+    syntax = (A.many().many())  # groups of groups of "a"
+    sql = "a a a"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    assert isinstance(ast.focus, ManyResult)
+
+
+def test_named_many() -> None:
+    A = literal("a").bind("alpha")
+    syntax = A.many()
+    sql = "a a"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    # Expect [NamedResult("alpha", "a"), NamedResult("alpha", "a")]
+    flattened, _ = ast.bimap(None)
+    assert all(isinstance(x, NamedResult) for x in flattened)
+
+
+def test_or_named() -> None:
+    A = literal("a").bind("x")
+    B = literal("b").bind("y")
+    syntax = A | B
+    sql = "b"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    # Either NamedResult("y", "b") or just "b", depending on your design
+    assert isinstance(ast.focus, OrResult)
+    value, _ = ast.bimap(None)
+    assert value == NamedResult(name="y", value=TokenGen.from_string("b"))
+
+
+def test_then_associativity() -> None:
+    A = literal("a")
+    B = literal("b")
+    C = literal("c")
+    syntax = A + B + C
+    sql = "a b c"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    # Should be ThenResult(ThenResult(A,B),C)
+    assert ast.focus == ThenResult(kind=ThenKind.BOTH, 
+                                   left=ThenResult(kind=ThenKind.BOTH, 
+                                                   left=TokenGen.from_string('a'), 
+                                                   right=TokenGen.from_string('b')), 
+                                    right=TokenGen.from_string('c'))
+
+
+def test_ambiguous() -> None:
+    A = literal("a")
+    B = literal("a") + literal("b")
+    syntax = A | B
+    sql = "a"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    # Does it prefer A (shorter) or B (fails)? Depends on design.
+    assert ast.focus == OrResult(TokenGen.from_string("a"))
+
+
+def test_combo() -> None:
+    A = literal("a").bind("a")
+    B = literal("b")
+    C = literal("c").bind("c")
+    syntax = ((A + B).many() | C) + B
+    sql = "a b a b c b"
+    # Should fail, as we discussed earlier
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    assert isinstance(ast, Error)
+
+
+def test_optional():
+    A = literal("a").bind("a")
+    syntax = A.optional()
+    ast1 = parse(syntax(Parser), "", dialect="sqlite")
+    v1, _ = ast1.bimap(None)
+    assert v1 is None
+    ast2 = parse(syntax(Parser), "a", dialect="sqlite")
+    v2, _ = ast2.bimap(None)
+    assert v2 == NamedResult(name='a', value=TokenGen.from_string('a'))
+
+