feat: Parent chain matching - Add support for dot notation in identifier names to specify parent relationships

Author: elifarley

src/cedarscript_editor/cedarscript_editor.py

@@ -106,20 +106,17 @@ def _update_command(self, cmd: UpdateCommand):
         lines = src.splitlines()
 
         identifier_finder = IdentifierFinder(file_path, src, RangeSpec.EMPTY)
-
+            
         search_range = RangeSpec.EMPTY
+        move_src_range = None
         match action:
             case MoveClause():
                 # READ + DELETE region  : action.region (PARENT RESTRICTION: target.as_marker)
                 move_src_range = restrict_search_range(action.region, target, identifier_finder, lines)
                 # WRITE region: action.insert_position
                 search_range = restrict_search_range(action.insert_position, None, identifier_finder, lines)
-            case _:
-                move_src_range = None
-                # Set range_spec to cover the identifier
-                match action:
-                    case RegionClause(region=region) | InsertClause(insert_position=region):
-                        search_range = restrict_search_range(region, target, identifier_finder, lines)
+            case RegionClause(region=region) | InsertClause(insert_position=region):
+                search_range = restrict_search_range(region, target, identifier_finder, lines)
 
         # UPDATE FUNCTION "_check_raw_id_fields_item"
         # FROM FILE "refactor-benchmark/checks_BaseModelAdminChecks__check_raw_id_fields_item/checks.py"

src/cedarscript_editor/tree_sitter_identifier_finder.py

@@ -79,19 +79,40 @@ def _find_identifier(self,
         or None if not found
         """
         query_info_key = marker.type
+        identifier_name = marker.value
         match marker.type:
             case 'method':
                 query_info_key = 'function'
         try:
-            candidates = (
-                self.language.query(self.query_info[query_info_key].format(name=marker.value))
+            all_restrictions: list[ParentRestriction] = [parent_restriction]
+            # Extract parent name if using dot notation
+            if '.' in identifier_name:
+                *parent_parts, identifier_name = identifier_name.split('.')
+                all_restrictions.append("." + '.'.join(reversed(parent_parts)))
+
+            # Get all node candidates first
+            candidate_nodes = (
+                self.language.query(self.query_info[query_info_key].format(name=identifier_name))
                 .captures(self.tree.root_node)
             )
-            # TODO discard candidates that aren't of type 'marker.type'
-            candidates: list[IdentifierBoundaries] = [ib for ib in capture2identifier_boundaries(
-                candidates,
-                self.lines
-            ) if ib.match_parent(parent_restriction)]
+            if not candidate_nodes:
+                return None
+
+            # Convert captures to boundaries and filter by parent
+            candidates: list[IdentifierBoundaries] = []
+            for ib in capture2identifier_boundaries(candidate_nodes, self.lines):
+                # For methods, verify the immediate parent is a class
+                if marker.type == 'method':
+                    if not ib.parents or not ib.parents[0].parent_type.startswith('class'):
+                        continue
+                # Check parent restriction (e.g., specific class name)
+                candidate_matched_all_restrictions = True
+                for pr in all_restrictions:
+                    if not ib.match_parent(pr):
+                        candidate_matched_all_restrictions = False
+                        break
+                if candidate_matched_all_restrictions:
+                    candidates.append(ib)
         except Exception as e:
             raise ValueError(f"Unable to capture nodes for {marker}: {e}") from e
 
@@ -100,13 +121,13 @@ def _find_identifier(self,
             return None
         if candidate_count > 1 and marker.offset is None:
             raise ValueError(
-                f"The {marker.type} identifier named `{marker.value}` is ambiguous (found {candidate_count} matches). "
+                f"The {marker.type} identifier named `{identifier_name}` is ambiguous (found {candidate_count} matches). "
                 f"Choose an `OFFSET` between 0 and {candidate_count - 1} to determine how many to skip. "
-                f"Example to reference the *last* `{marker.value}`: `OFFSET {candidate_count - 1}`"
+                f"Example to reference the *last* `{identifier_name}`: `OFFSET {candidate_count - 1}`"
             )
         if marker.offset and marker.offset >= candidate_count:
             raise ValueError(
-                f"There are only {candidate_count} {marker.type} identifiers named `{marker.value}`, "
+                f"There are only {candidate_count} {marker.type} identifiers named `{identifier_name}`, "
                 f"but 'OFFSET' was set to {marker.offset} (you can skip at most {candidate_count - 1} of those)"
             )
         candidates.sort(key=lambda x: x.whole.start)

src/text_manipulation/range_spec.py

@@ -372,9 +372,23 @@ def match_parent(self, parent_restriction: ParentRestriction) -> bool:
                 return True
             case RangeSpec():
                 return self.whole in parent_restriction
-            case str() as parent_name:
-                # TODO Implement advanced query syntax
-                return parent_name in [p.parent_name for p in self.parents]
+            case str() as parent_spec:
+                # Parent chain matching: Handle dot notation for parent relationships
+                parent_chain = parent_spec.split('.')
+                if len(parent_chain) == 1:
+                    # Simple case - just check if name is any of the parents
+                    return parent_spec in [p.parent_name for p in self.parents]
+                parent_chain = [p for p in parent_chain if p]
+                if len(parent_chain) > len(self.parents):
+                    return False
+                # len(parent_chain) <= len(self.parents)
+                # Check parent chain partially matches (
+                #   sub-chain match when there are fewer items in 'parent_chain' than in 'self.parents'
+                # )
+                return all(
+                    expected == actual.parent_name
+                    for expected, actual in zip(parent_chain, self.parents)
+                )
             case _:
                 raise ValueError(f'Invalid parent restriction: {parent_restriction}')
 

tests/corpus/update.identifier.parent-chain/1.py

@@ -0,0 +1,24 @@
+class A:
+    def a(self):
+        pass
+    def calculate(self,
+        a,
+        b,
+        c,
+        d,
+        e
+    ):
+        pass
+class Parent1OfB:
+    class Parent2OfB:
+        class B:
+            def a(self):
+                pass
+            def calculate(self,
+                a,
+                b,
+                c,
+                d,
+                e
+            ):
+                pass

tests/corpus/update.identifier.parent-chain/chat.xml

@@ -0,0 +1,11 @@
+<no-train>
+```CEDARScript
+UPDATE METHOD "Parent2OfB.B.calculate"
+FROM FILE "1.py"
+REPLACE LINE 1
+WITH CONTENT '''
+@0:def calculate(self, line_1,
+@1:line_2,
+''';
+```
+</no-train>

tests/corpus/update.identifier.parent-chain/expected.1.py

@@ -0,0 +1,25 @@
+class A:
+    def a(self):
+        pass
+    def calculate(self,
+        a,
+        b,
+        c,
+        d,
+        e
+    ):
+        pass
+class Parent1OfB:
+    class Parent2OfB:
+        class B:
+            def a(self):
+                pass
+            def calculate(self, line_1,
+                line_2,
+                a,
+                b,
+                c,
+                d,
+                e
+            ):
+                pass