ast-pattern-engine 1.0.0__tar.gz → 1.0.1__tar.gz

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/.github/workflows/ci.yml

@@ -7,37 +7,62 @@ on:
     branches: [ "main" ]
 
 jobs:
+  format:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push'
+    permissions:
+      contents: write
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+
+    - name: Auto-format with Ruff
+      run: uv run ruff format
+
+    - name: Auto-fix lint with Ruff
+      run: uv run ruff check --fix
+
+    - name: Commit formatting changes
+      uses: stefanzweifel/git-auto-commit-action@v5
+      with:
+        commit_message: "style: auto-format with ruff"
+
   test:
     runs-on: ubuntu-latest
+    needs: format
+    if: always()
     strategy:
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
 
     steps:
     - uses: actions/checkout@v4
-    
+      with:
+        ref: ${{ github.ref }}
+
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
-        
+
     - name: Install uv
       uses: astral-sh/setup-uv@v5
       with:
         enable-cache: true
-        
+
     - name: Install dependencies
-      run: uv sync --all-extras
-      
-    - name: Check formatting with Ruff
-      run: uv run ruff format --check
-      
+      run: uv sync --all-extras --all-groups
+
     - name: Lint with Ruff
       run: uv run ruff check
-      
+
     - name: Run tests with pytest
       run: uv run pytest --cov=src --cov-report=xml
-      
+
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v4
       env:

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ast-pattern-engine
-Version: 1.0.0
+Version: 1.0.1
 Summary: A library for regex-inspired fine-grained AST pattern matching and replacing
 Project-URL: Homepage, https://github.com/80sVectorz/ast_pattern_engine
 Project-URL: Repository, https://github.com/80sVectorz/ast_pattern_engine

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ast-pattern-engine"
-version = "1.0.0"
+version = "1.0.1"
 description = "A library for regex-inspired fine-grained AST pattern matching and replacing"
 readme = "README.md"
 authors = [
@@ -40,4 +40,8 @@ pythonpath = ["src"]
 [dependency-groups]
 dev = [
     "pytest-cov>=7.1.0",
+    "ruff>=0.11.0",
 ]
+
+[tool.ruff.lint]
+ignore = ["F841"] # Ignore unused variable assignments

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/src/ast_pattern_engine/core.py

@@ -8,7 +8,11 @@ class Pattern(ast.AST):
 
     # public API
     def match_node(
-        self, node: object, bindings: dict[str, object] | None = None, *, _force_list: bool = False
+        self,
+        node: object,
+        bindings: dict[str, object] | None = None,
+        *,
+        _force_list: bool = False,
     ):
         """Match *node* and return updated *bindings* or *None*."""
         raise NotImplementedError
@@ -21,7 +25,11 @@ class Pattern(ast.AST):
 
 class SequencePattern(Pattern):
     def match_node(
-        self, node: object, bindings: dict[str, object] | None = None, *, _force_list: bool = False
+        self,
+        node: object,
+        bindings: dict[str, object] | None = None,
+        *,
+        _force_list: bool = False,
     ):
         # Matching is handled by engine._match_sequence
         raise NotImplementedError(

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/src/ast_pattern_engine/engine.py

@@ -26,7 +26,9 @@ def _match_patterns(
 
     match first:
         case PatternGroup(pattern=sub_pattern, key=key):
-            res = _match_patterns(sub_pattern, nodes, pos, dict(bindings), _force_list=_force_list)
+            res = _match_patterns(
+                sub_pattern, nodes, pos, dict(bindings), _force_list=_force_list
+            )
             if res:
                 new_bindings = res[-1][0]
                 if key is not None:
@@ -40,7 +42,9 @@ def _match_patterns(
             new_bindings = dict(bindings)
             n_reps = 0
             while n_reps < (max_matches or len(nodes)) and pos < len(nodes):
-                res = _match_patterns([sub_pattern], nodes, pos, dict(new_bindings), _force_list=True)
+                res = _match_patterns(
+                    [sub_pattern], nodes, pos, dict(new_bindings), _force_list=True
+                )
                 if not res:
                     break
                 new_bindings, pos = res[-1]
@@ -54,7 +58,9 @@ def _match_patterns(
             new_pos = pos
             n_matches = 0
             for pattern in sub_patterns:
-                res = _match_patterns([pattern], nodes, pos, dict(bindings), _force_list=_force_list)
+                res = _match_patterns(
+                    [pattern], nodes, pos, dict(bindings), _force_list=_force_list
+                )
                 if res:
                     n_matches += 1
                     if n_matches == 1:
@@ -74,7 +80,9 @@ def _match_patterns(
                 out.append((new_bindings, pos))
 
         case Optional(pattern=sub_pattern, key=key):
-            res = _match_patterns([sub_pattern], nodes, pos, dict(bindings), _force_list=_force_list)
+            res = _match_patterns(
+                [sub_pattern], nodes, pos, dict(bindings), _force_list=_force_list
+            )
             if res:
                 new_bindings, new_pos = res[-1]
                 if key is not None:
@@ -88,13 +96,17 @@ def _match_patterns(
         case _:
             # single node pattern
             if pos < len(nodes):
-                res = first.match_node(nodes[pos], dict(bindings), _force_list=_force_list)
+                res = first.match_node(
+                    nodes[pos], dict(bindings), _force_list=_force_list
+                )
                 if res is not None:
                     out.append((res, pos + 1))
 
     # Match remaining patterns
     if out and remaining:
-        rem_res = _match_patterns(remaining, nodes, out[-1][1], out[-1][0], _force_list=_force_list)
+        rem_res = _match_patterns(
+            remaining, nodes, out[-1][1], out[-1][0], _force_list=_force_list
+        )
         if not rem_res:
             return []
         out.extend(rem_res)

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/src/ast_pattern_engine/nodes/basic.py

@@ -25,7 +25,13 @@ class Bind(Pattern):
     def __init__(self, key: str):
         self.key = key
 
-    def match_node(self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False):
+    def match_node(
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
+    ):
         bindings = bindings or {}
         if self.key in bindings:
             if not _force_list:
@@ -41,7 +47,13 @@ class WildCard(Pattern):
 
     def __init__(self): ...
 
-    def match_node(self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False):
+    def match_node(
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
+    ):
         bindings = bindings or {}
         return bindings
 
@@ -58,7 +70,13 @@ class NodePattern(Pattern):
         self.node_type = node_type
         self.field_patterns = field_patterns
 
-    def match_node(self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False):
+    def match_node(
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
+    ):
         bindings = bindings or {}
         if not isinstance(node, self.node_type):
             return None
@@ -85,9 +103,7 @@ class NodePattern(Pattern):
                             return None
                         merged[k] = self._to_list(merged[k]) + self._to_list(v)
                     else:
-                        merged[k] = (
-                            self._to_list(v) if _force_list else v
-                        )
+                        merged[k] = self._to_list(v) if _force_list else v
             else:
                 if val != pat:
                     return None
@@ -113,7 +129,11 @@ class Collect(Pattern):
         self.key = key
 
     def match_node(
-        self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
     ) -> None | dict[str, Any]:
         bindings = bindings or {}
         # Collect is a binding boundary — inner patterns always see _force_list=False
@@ -167,7 +187,13 @@ class Filter(Pattern):
         self.predicate = predicate
         self.key = key
 
-    def match_node(self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False):
+    def match_node(
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
+    ):
         bindings = bindings or {}
         if not self.predicate(node):
             return None
@@ -192,7 +218,13 @@ class Not(Pattern):
     def __init__(self, pattern: Pattern):
         self.pattern = pattern
 
-    def match_node(self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False):
+    def match_node(
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
+    ):
         bindings = bindings or {}
 
         # Use _match_patterns so that SequencePatterns (like OneOf) don't
@@ -214,7 +246,13 @@ class Contains(Pattern):
     def __init__(self, pattern: Sequence[Pattern]):
         self.pattern = list(pattern)
 
-    def match_node(self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False):
+    def match_node(
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
+    ):
         bindings = bindings or {}
         finder = SingleOccurrenceFinder(self.pattern)
         finder.visit(node)
@@ -245,12 +283,20 @@ class AllOf(Pattern):
     def __init__(self, patterns: Sequence[Pattern]):
         self.patterns = list(patterns)
 
-    def match_node(self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False):
+    def match_node(
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
+    ):
         bindings = bindings or {}
         new_bindings = dict(bindings)
 
         for pattern in self.patterns:
-            new_bindings = pattern.match_node(node, new_bindings, _force_list=_force_list)
+            new_bindings = pattern.match_node(
+                node, new_bindings, _force_list=_force_list
+            )
             if new_bindings is None:
                 return None
         return new_bindings
@@ -269,7 +315,13 @@ class AnyOf(Pattern):
     def __init__(self, patterns: Sequence[Pattern]):
         self.patterns = list(patterns)
 
-    def match_node(self, node: Any, bindings: dict[str, Any] | None = None, *, _force_list: bool = False):
+    def match_node(
+        self,
+        node: Any,
+        bindings: dict[str, Any] | None = None,
+        *,
+        _force_list: bool = False,
+    ):
         bindings = bindings or {}
         merged = dict(bindings)
         matched_any = False

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/src/ast_pattern_engine/nodes/sequences.py

@@ -6,7 +6,11 @@ from ast_pattern_engine.core import Pattern
 
 class SequencePattern(Pattern):
     def match_node(
-        self, node: object, bindings: dict[str, object] | None = None, *, _force_list: bool = False
+        self,
+        node: object,
+        bindings: dict[str, object] | None = None,
+        *,
+        _force_list: bool = False,
     ):
         # Matching is handled by engine._match_sequence
         raise NotImplementedError(

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/src/ast_pattern_engine/visitors.py

@@ -1,3 +1,4 @@
+from typing import TypeAlias
 import ast
 from typing import Any
 from collections.abc import Sequence, Callable
@@ -5,7 +6,7 @@ from collections.abc import Sequence, Callable
 from ast_pattern_engine.core import Pattern
 from ast_pattern_engine.engine import _match_patterns
 
-type ReplaceResult = ast.AST | list[ast.AST] | None
+ReplaceResult: TypeAlias = ast.AST | list[ast.AST] | None
 
 
 class PatternTransformer(ast.NodeTransformer):

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/patterns/test_any_of.py

@@ -1,32 +1,22 @@
 import ast
 from ast_pattern_engine.nodes.basic import AnyOf, NodePattern, Collect
 
+
 def test_any_of_matches_and_conflicts():
     node = ast.parse("1").body[0].value
-    
+
     # First matches
-    pattern1 = AnyOf([
-        NodePattern(ast.Constant),
-        NodePattern(ast.Name)
-    ])
+    pattern1 = AnyOf([NodePattern(ast.Constant), NodePattern(ast.Name)])
     assert pattern1.match_node(node, {"existing": 1}) == {"existing": 1}
-    
+
     # Second matches
-    pattern2 = AnyOf([
-        NodePattern(ast.Name),
-        NodePattern(ast.Constant)
-    ])
+    pattern2 = AnyOf([NodePattern(ast.Name), NodePattern(ast.Constant)])
     assert pattern2.match_node(node, {}) == {}
-    
+
     # None matches
-    pattern3 = AnyOf([
-        NodePattern(ast.Name),
-        NodePattern(ast.Assign)
-    ])
+    pattern3 = AnyOf([NodePattern(ast.Name), NodePattern(ast.Assign)])
     assert pattern3.match_node(node, {}) is None
 
     # Match produces conflicting key
-    pattern4 = AnyOf([
-        Collect(NodePattern(ast.Constant), "c")
-    ])
+    pattern4 = AnyOf([Collect(NodePattern(ast.Constant), "c")])
     assert pattern4.match_node(node, {"c": "conflict"}) is None

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/patterns/test_collect.py

@@ -1,6 +1,7 @@
 import ast
 from ast_pattern_engine.nodes.basic import Collect, NodePattern
 
+
 def test_collect_match_single_constant():
     node = ast.parse("1").body[0]
     assert isinstance(node, ast.Expr)

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/patterns/test_filter.py

@@ -3,6 +3,7 @@ from ast_pattern_engine.nodes.basic import Filter
 from ast_pattern_engine.nodes.sequences import Repetition
 from ast_pattern_engine.engine import match_sequence
 
+
 def test_filter_no_key():
     node = ast.parse("1").body[0].value
     # Matches, no key bound
@@ -17,14 +18,14 @@ def test_filter_no_key():
 def test_filter_with_key_and_conflicts():
     node = ast.parse("1").body[0].value
     pattern = Filter(lambda x: isinstance(x, ast.Constant), key="my_filter")
-    
+
     # Matches and binds
     res = pattern.match_node(node, {})
     assert res == {"my_filter": node}
-    
+
     # Conflict on duplicate key without force
     assert pattern.match_node(node, {"my_filter": "existing"}) is None
-    
+
     # When inside a Repetition, ancestor forces list
     rep_pattern = Repetition(pattern)
     # Match node directly against the filter while simulating the Repetition context

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/patterns/test_one_of.py

@@ -3,6 +3,7 @@ from ast_pattern_engine.nodes.basic import Collect, WildCard, NodePattern
 from ast_pattern_engine.nodes.sequences import OneOf
 from ast_pattern_engine.engine import _match_patterns, match_sequence
 
+
 def test_one_of_non_strict_returns_first_match():
     nodes = [ast.parse(src).body[0] for src in ("1", "2")]
     pattern = [
@@ -49,9 +50,9 @@ def test_one_of_strict_matches_exactly_one_pattern():
     ]
 
     result = _match_patterns(pattern, nodes, 0, {})
-    assert (
-        len(result) == 0
-    ), "Expected strict OneOf not to match because multiple sub patterns match"
+    assert len(result) == 0, (
+        "Expected strict OneOf not to match because multiple sub patterns match"
+    )
 
     # Section B: Test strict mode with exactly one matching pattern for each line
     nodes = [ast.parse(src).body[0] for src in ("1", "x=2")]

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/patterns/test_pattern_group.py

@@ -3,6 +3,7 @@ from ast_pattern_engine.nodes.basic import Collect, WildCard, NodePattern
 from ast_pattern_engine.nodes.sequences import PatternGroup
 from ast_pattern_engine.engine import _match_patterns, match_sequence
 
+
 def test_pattern_group_collects_inner_bindings_under_key():
     nodes = [ast.parse(src).body[0].value for src in ("1", "2")]  # type: ignore
     pattern = [

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/patterns/test_repetition.py

@@ -3,6 +3,7 @@ from ast_pattern_engine.nodes.basic import Collect, WildCard
 from ast_pattern_engine.nodes.sequences import Repetition
 from ast_pattern_engine.engine import _match_patterns
 
+
 def test_collect_inside_one_or_more_accumulates_nodes():
     nodes = [ast.parse(str(i)).body[0].value for i in range(3)]  # type: ignore
     pattern = [Repetition(Collect(WildCard(), "item"))]

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/test_engine.py

@@ -2,6 +2,7 @@ import ast
 from ast_pattern_engine.nodes.basic import Collect, WildCard
 from ast_pattern_engine.engine import match_sequence
 
+
 def test_match_sequence_returns_non_overlapping_bindings():
     nodes = [ast.parse(text).body[0] for text in ("a = 1", "b = 2", "c = 3")]
     pattern = [Collect(WildCard(), "assign")]

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/visitors/test_bottom_up_pattern_transformer.py

@@ -14,7 +14,7 @@ def _constant(value, template):
 
 
 def test_bottom_up_pattern_transformer_collapses_children_before_parent():
-    source = "def foo():\n" "    return (1 + 2) + (3 + 4)\n"
+    source = "def foo():\n    return (1 + 2) + (3 + 4)\n"
     tree = ast.parse(source)
     pattern = [Collect(NodePattern(ast.BinOp), "expr")]
 
@@ -60,6 +60,7 @@ def test_bu_transformer_list_manipulation():
     # Return multiple nodes (expands)
     def expand(_):
         return [_parse_stmt("pass"), _parse_stmt("pass")]
+
     transformer3 = BottomUpPatternTransformer(pattern, {"a": expand})
     res3 = transformer3.visit(ast.parse("x = 1"))
     assert len(res3.body) == 2

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/visitors/test_pattern_finder.py

@@ -17,7 +17,10 @@ def test_pattern_finder_collects_node_matches():
 def test_pattern_finder_scan_list():
     tree = ast.parse("a = 1\nb = 2\nc = 3")
     # A sequence of length 2 to trigger `_scan_list` len(self.pattern) > 1 branch
-    pattern = [Collect(NodePattern(ast.Assign), "a"), Collect(NodePattern(ast.Assign), "b")]
+    pattern = [
+        Collect(NodePattern(ast.Assign), "a"),
+        Collect(NodePattern(ast.Assign), "b"),
+    ]
     finder = PatternFinder(pattern)
     finder.visit(tree)
     # Print the matches to debug

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/visitors/test_pattern_transformer.py

@@ -123,7 +123,7 @@ def test_pt_nonlist_replace_errors():
 
     # Error: handler returns non-list
     def bad_handler(_):
-        return _constant_val(2) # type: ignore
+        return _constant_val(2)  # type: ignore
 
     transformer2 = PatternTransformer(pattern, {"c": bad_handler})
     with pytest.raises(TypeError, match="Handler must return list"):
@@ -133,7 +133,7 @@ def test_pt_nonlist_replace_errors():
 def test_pt_plan_errors():
     tree = ast.parse("a = 1\nb = 2")
     pattern = [Collect(NodePattern(ast.Assign), "a")]
-    
+
     # key not in bindings (should silently continue)
     transformer1 = PatternTransformer(pattern, {"missing_key": lambda b: []})
     transformer1.visit(ast.parse("a = 1"))
@@ -142,11 +142,12 @@ def test_pt_plan_errors():
     transformer2 = PatternTransformer(pattern, {"a": lambda b: []})
     # override matching to return empty list for testing
     b = {"a": []}
-    transformer2.matches.append(b) 
-    
+    transformer2.matches.append(b)
+
     # handler returns non-list
     def bad_plan_handler(_):
         return "not a list"
+
     transformer3 = PatternTransformer(pattern, {"a": bad_plan_handler})
     with pytest.raises(TypeError, match="must return `list"):
         transformer3.visit(ast.parse("a = 1"))
@@ -166,6 +167,7 @@ def test_pt_nested_replace_and_delete():
     # Replace nested nodes
     def replace_with_99(_):
         return [_constant_val(99)]
+
     transformer2 = PatternTransformer(pattern, {"c": replace_with_99})
     res2 = transformer2.visit(ast.parse("x = [1, 2, 3]"))
     assert all(elt.value == 99 for elt in res2.body[0].value.elts)
@@ -174,18 +176,20 @@ def test_pt_nested_replace_and_delete():
 def test_pt_dict_as_nodes():
     tree = ast.parse("x = 1")
     pattern = [Collect(NodePattern(ast.Assign), "a")]
-    
+
     # We force the binding to be a dict to trigger dict handling in _as_nodes
     class DictTransformer(PatternTransformer):
         def _plan(self, seq):
             # Intercept and mutate bindings
             res = super()._plan(seq)
             return res
-            
+
     transformer = DictTransformer(pattern, {"a": lambda b: [_parse_stmt("x = 2")]})
     # Override match manually
-    mtch = transformer._match_patterns = lambda p, s, i, b: [({"a": {"nested": s[i]}}, i+1)] if i < len(s) else []
-    
+    mtch = transformer._match_patterns = lambda p, s, i, b: (
+        [({"a": {"nested": s[i]}}, i + 1)] if i < len(s) else []
+    )
+
     res = transformer.visit(tree)
     assert isinstance(res.body[0], ast.Assign)
     assert res.body[0].value.value == 2
@@ -195,14 +199,14 @@ def test_pt_generic_visit_list_field_error():
     tree = ast.parse("a = 1")
     pattern = [Collect(NodePattern(ast.Assign), "a")]
     transformer = PatternTransformer(pattern, {})
-    
+
     # Force a child to not be an AST node
     class BadTransformer(PatternTransformer):
         def visit(self, node):
             if isinstance(node, ast.Assign):
                 return "Not an AST node"
             return super().visit(node)
-            
+
     bad_transformer = BadTransformer(pattern, {})
     with pytest.raises(TypeError, match="must contain AST nodes"):
         bad_transformer.visit(ast.parse("a = 1"))

{ast_pattern_engine-1.0.0 → ast_pattern_engine-1.0.1}/tests/visitors/test_single_occurrence_finder.py

@@ -29,8 +29,8 @@ def test_single_occurrence_finder_early_exit():
     tree = ast.parse("a = 1\nb = 2")
     pattern = [NodePattern(ast.Assign)]
     finder = SingleOccurrenceFinder(pattern)
-    
+
     # We manually set found to True to test early exit in visit
     finder.found = True
     finder.visit(tree)
-    assert finder.match_node is None # Didn't actually match because it early exited
+    assert finder.match_node is None  # Didn't actually match because it early exited