dotted-notation 0.44.6__tar.gz → 0.44.7__tar.gz

{dotted_notation-0.44.6 → dotted_notation-0.44.7}/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to `dotted` are recorded here. Versions prior to
 the ones listed are omitted — browse git history for earlier entries.
 
+## [0.44.7]
+
+### Fixed
+- `groups='patterns'` capture positions for variadic patterns: literals
+  are now correctly excluded when the pattern contains a group or
+  recursive op, so `translate`'s `$N` numbering counts pattern segments
+  only, as documented. Previously `a.(x,y).*` numbered `$0='a'` (a
+  literal), and `**.c` captured the literal `c`.
+
+### Changed
+- A group is one pattern segment: it captures the path segments its
+  matching branch consumed as a single group, keeping `$N` positions
+  stable across branches of different lengths. `x.(a.b,c)` matching
+  `x.a.b` now captures `('x', 'a.b')` instead of `('x', 'a', 'b')`.
+  Parentheses thereby act as a regex-like capture group: `x.(a.b)`
+  captures `'a.b'` as one group where `x.a.b` captures `'a', 'b'`.
+  Nested patterns inside a branch fold into the group's capture, as
+  with `**`.
+
 ## [0.44.6]
 
 ### Added

{dotted_notation-0.44.6/dotted_notation.egg-info → dotted_notation-0.44.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.44.6
+Version: 0.44.7
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License: MIT
@@ -508,6 +508,17 @@ excluding literals:
     >>> dotted.match('hello.*', 'hello.there.bye', groups=GroupMode.patterns)
     ('hello.there.bye', ('there.bye',))
 
+Op groups match like regex alternation, and parentheses act as a capture
+group: a group captures the segments its matching branch consumed as a
+single group, and counts as one pattern position:
+
+    >>> dotted.match('a.(x,y).*', 'a.x.z', groups=GroupMode.patterns, partial=False)
+    ('a.x.z', ('x', 'z'))
+    >>> dotted.match('x.(a.b,c)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+    >>> dotted.match('x.(a.b)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+
 <a id="replace"></a>
 ### Replace
 

{dotted_notation-0.44.6 → dotted_notation-0.44.7}/README.md

@@ -468,6 +468,17 @@ excluding literals:
     >>> dotted.match('hello.*', 'hello.there.bye', groups=GroupMode.patterns)
     ('hello.there.bye', ('there.bye',))
 
+Op groups match like regex alternation, and parentheses act as a capture
+group: a group captures the segments its matching branch consumed as a
+single group, and counts as one pattern position:
+
+    >>> dotted.match('a.(x,y).*', 'a.x.z', groups=GroupMode.patterns, partial=False)
+    ('a.x.z', ('x', 'z'))
+    >>> dotted.match('x.(a.b,c)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+    >>> dotted.match('x.(a.b)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+
 <a id="replace"></a>
 ### Replace
 

{dotted_notation-0.44.6 → dotted_notation-0.44.7}/dotted/api.py

@@ -762,6 +762,13 @@ def match(pattern, path, groups=False, partial=True, strict=False):
     'b'
     >>> match('(!a)', 'a')
 
+    A group is one pattern segment: it captures the segments its branch
+    consumed as a single group, and counts as one pattern position:
+    >>> match('x.(a.b,c)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+    >>> match('a.(x,y).*', 'a.x.z', groups='patterns', partial=False)
+    ('a.x.z', ('x', 'z'))
+
     Recursive patterns:
     >>> match('**.c', 'a.b.c')
     'a.b.c'
@@ -789,8 +796,7 @@ def match(pattern, path, groups=False, partial=True, strict=False):
         result = base.match_ops(list(pats), list(path_ops), partial)
         if result is None:
             return returns(None, [])
-        # TODO: pattern-only filtering for variadic matches
-        return returns(path, result)
+        return returns(path, [v for v, _ in result], [p for _, p in result])
 
     # Original non-recursive match logic
     _matches = []

{dotted_notation-0.44.6 → dotted_notation-0.44.7}/dotted/base.py

@@ -45,9 +45,9 @@ def has_any(gen):
 def match_ops(pats, path_ops, partial):
     """
     Match a list of pattern ops against a list of path ops.
-    Returns a list of match values on success, None on failure.
-    Dispatches to each op's do_match, which decides how many path
-    segments it consumes.
+    Returns a list of (value, is_pattern) capture pairs on success, None
+    on failure.  Dispatches to each op's do_match, which decides how
+    many path segments it consumes.
     """
     if pats:
         return pats[0].do_match(pats[1:], path_ops, partial)
@@ -221,9 +221,10 @@ class TraversalOp(Op):
         rest = match_ops(rest_pats, path_ops[1:], partial)
         if rest is None:
             return None
+        is_pat = self.is_pattern()
         if isinstance(m, (tuple, list)):
-            return [_m.val for _m in m] + rest
-        return [m.val] + rest
+            return [(_m.val, is_pat) for _m in m] + rest
+        return [(m.val, is_pat)] + rest
 
 
 class MatchOp(Op):

{dotted_notation-0.44.6 → dotted_notation-0.44.7}/dotted/groups.py

@@ -109,11 +109,23 @@ class OpGroup(base.TraversalOp):
         concrete path can only be produced by one branch at a time, so
         disjunction, first-match, and conjunction all reduce to "any branch
         matches"; cut markers don't constrain matching either.
+
+        The group is one pattern segment: it contributes a single capture —
+        the path segments its branch consumed, assembled — flagged as a
+        pattern match (like Recursive).
         """
+        from . import results
         for branch in base.branches_only(self.branches):
-            result = base.match_ops(list(branch) + list(rest_pats), path_ops, partial)
-            if result is not None:
-                return result
+            branch_ops = list(branch)
+            for n in range(len(path_ops) + 1):
+                consumed = base.match_ops(branch_ops, path_ops[:n], False)
+                if consumed is None:
+                    continue
+                rest = base.match_ops(list(rest_pats), path_ops[n:], partial)
+                if rest is None:
+                    continue
+                combined = results.assemble(path_ops[:n])
+                return [(combined, True)] + rest
         return None
 
     def _render(self, top=True):
@@ -552,7 +564,7 @@ class OpGroupNot(OpGroup):
         if rest is None:
             return None
         seg_val = getattr(getattr(kop, 'op', kop), 'value', kop)
-        return [seg_val] + rest
+        return [(seg_val, True)] + rest
 
     def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, **kwargs):
         inner = self.inner

{dotted_notation-0.44.6 → dotted_notation-0.44.7}/dotted/recursive.py

@@ -133,7 +133,7 @@ class Recursive(BaseOp):
             if rest is None:
                 continue
             combined = results.assemble(path_ops[:n])
-            return [combined] + rest
+            return [(combined, True)] + rest
         return None
 
     def _effective_branches(self):

{dotted_notation-0.44.6 → dotted_notation-0.44.7/dotted_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.44.6
+Version: 0.44.7
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License: MIT
@@ -508,6 +508,17 @@ excluding literals:
     >>> dotted.match('hello.*', 'hello.there.bye', groups=GroupMode.patterns)
     ('hello.there.bye', ('there.bye',))
 
+Op groups match like regex alternation, and parentheses act as a capture
+group: a group captures the segments its matching branch consumed as a
+single group, and counts as one pattern position:
+
+    >>> dotted.match('a.(x,y).*', 'a.x.z', groups=GroupMode.patterns, partial=False)
+    ('a.x.z', ('x', 'z'))
+    >>> dotted.match('x.(a.b,c)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+    >>> dotted.match('x.(a.b)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+
 <a id="replace"></a>
 ### Replace
 

{dotted_notation-0.44.6 → dotted_notation-0.44.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dotted_notation"
-version = "0.44.6"
+version = "0.44.7"
 description = "Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms"
 readme = "README.md"
 requires-python = ">=3.6"