Fix significant bugs

Author: elifarley

pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
 ]
 keywords = ["cedarscript", "code-editing", "refactoring", "code-analysis", "sql-like", "ai-assisted-development"]
 dependencies = [
-    "cedarscript-ast-parser>=0.2.10",
+    "cedarscript-ast-parser==0.2.11",
     "grep-ast==0.3.3",
     "tree-sitter-languages==1.10.2",
 ]

src/cedarscript_editor/cedarscript_editor.py

@@ -6,12 +6,12 @@
     SelectCommand, CreateCommand, IdentifierFromFile, Segment, Marker, MoveClause, DeleteClause, \
     InsertClause, ReplaceClause, EditingAction, BodyOrWhole, RegionClause, MarkerType
 from cedarscript_ast_parser.cedarscript_ast_parser import MarkerCompatible, RelativeMarker, \
-    RelativePositionType
+    RelativePositionType, Region, SingleFileClause
 from text_manipulation import (
     IndentationInfo, IdentifierBoundaries, RangeSpec, read_file, write_file, bow_to_search_range
 )
 
-from .tree_sitter_identifier_finder import IdentifierFinder, find_identifier
+from .tree_sitter_identifier_finder import IdentifierFinder
 
 
 class CEDARScriptEditorException(Exception):
@@ -105,26 +105,21 @@ def _update_command(self, cmd: UpdateCommand):
         src = read_file(file_path)
         lines = src.splitlines()
 
-        source_info: tuple[str | bytes, str | Sequence[str]] = (file_path, src)
-
-        identifier_finder = find_identifier(source_info)
-
-        # TODO test...
+        identifier_finder = IdentifierFinder(file_path, src, RangeSpec.EMPTY)
 
+        search_range = RangeSpec.EMPTY
         match action:
             case MoveClause():
-                # (Check parse_update_command)
-                # when action=MoveClause example (MOVE roll TO AFTER score):
-                #   action.deleteclause.region=WHOLE
-                #   action.as_marker = action.insertclause.as_marker
-                #   action.insertclause.insert_position=FUNCTION(score)
-                #   target.as_marker = FUNCTION(roll) (the one to delete)
-                search_range = RangeSpec.EMPTY
-                move_src_range = restrict_search_range(action, target, identifier_finder, lines)
+                # 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
-                search_range = restrict_search_range(action, target, identifier_finder, lines)
+                match action:
+                    case RegionClause(region=region):
+                        search_range = restrict_search_range(action.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"
@@ -134,11 +129,17 @@ def _update_command(self, cmd: UpdateCommand):
         # ''';
         # target = IdentifierFromFile(file_path='refactor-benchmark/checks_BaseModelAdminChecks__check_raw_id_fields_item/checks.py', identifier_type=<MarkerType.FUNCTION: 'function'>, name='_check_raw_id_fields_item', where_clause=None, offset=None)
         # action = ReplaceClause(region=Marker(type=<MarkerType.LINE: line>, value=def _check_raw_id_fields_item(self, obj, field_name, label):, offset=None))
-        if search_range.line_count and not isinstance(action.region if hasattr(action, 'region') else None, Segment):
-            marker, search_range = find_marker_or_segment(action, lines, search_range)
-            search_range = restrict_search_range_for_marker(
-                marker, action, lines, search_range, identifier_finder
-            )
+        if search_range.line_count:
+            match action:
+                case RegionClause(region=Segment()):
+                    pass
+                case RegionClause(region=Marker()) if action.region.type in [MarkerType.FUNCTION, MarkerType.METHOD, MarkerType.CLASS]:
+                    pass
+                case _:
+                    marker, search_range = find_marker_or_segment(action, lines, search_range)
+                    search_range = restrict_search_range_for_marker(
+                        marker, action, lines, search_range, identifier_finder
+                    )
 
         match content:
             case str() | [str(), *_] | (str(), *_):
@@ -263,7 +264,7 @@ def find_index_range_for_region(region: BodyOrWhole | Marker | Segment | Relativ
                             pass
                         case _:
                             # TODO transform to RangeSpec
-                            mos = find_identifier(("TODO?.py", lines))(mos).body
+                            mos = IdentifierFinder("TODO?.py", lines, RangeSpec.EMPTY)(mos, search_range).body
             index_range = mos.to_search_range(
                 lines,
                 search_range.start if search_range else 0,
@@ -296,28 +297,38 @@ def find_marker_or_segment(
     return marker, search_range
 
 
-def restrict_search_range(action, target, identifier_finder: IdentifierFinder, lines: Sequence[str]) -> RangeSpec:
-    match target:
-        case IdentifierFromFile() as identifier_from_file:
-            identifier_marker = identifier_from_file.as_marker
-            identifier_boundaries = identifier_finder(identifier_marker)
-            if not identifier_boundaries:
-                raise ValueError(f"'{identifier_marker}' not found")
-            match action:
-                case RegionClause(region=region):
-                    match region:
-                        case BodyOrWhole() | RelativePositionType():
-                            return identifier_boundaries.location_to_search_range(region)
-                        case Marker() as inner_marker:
-                            match identifier_finder(inner_marker, identifier_boundaries.whole):
-                                case IdentifierBoundaries() as inner_boundaries:
-                                    return inner_boundaries.whole
-                                case RangeSpec() as inner_range_spec:
-                                    return inner_range_spec
-                        case Segment() as segment:
-                            return segment.to_search_range(lines, identifier_boundaries.whole)
-                        case _ as invalid:
-                            raise ValueError(f'Unsupported region type: {type(invalid)}')
+def restrict_search_range(
+        region: Region, parent_restriction: any,
+        identifier_finder: IdentifierFinder, lines: Sequence[str]
+) -> RangeSpec:
+    identifier_boundaries = None
+    match parent_restriction:
+        case IdentifierFromFile():
+            identifier_boundaries = identifier_finder(parent_restriction.as_marker)
+    match region:
+        case BodyOrWhole() | RelativePositionType():
+            match parent_restriction:
+                case IdentifierFromFile():
+                    match identifier_boundaries:
+                        case None:
+                            raise ValueError(f"'{parent_restriction}' not found")
+                case SingleFileClause():
+                    return RangeSpec.EMPTY
+                case None:
+                    raise ValueError(f"'{region}' requires parent_restriction")
+                case _:
+                    raise ValueError(f"'{region}' isn't compatible with {parent_restriction}")
+            return identifier_boundaries.location_to_search_range(region)
+        case Marker() as inner_marker:
+            match identifier_finder(inner_marker, identifier_boundaries.whole if identifier_boundaries is not None else None):
+                case IdentifierBoundaries() as inner_boundaries:
+                    return inner_boundaries.location_to_search_range(BodyOrWhole.WHOLE)
+                case RangeSpec() as inner_range_spec:
+                    return inner_range_spec
+        case Segment() as segment:
+            return segment.to_search_range(lines, identifier_boundaries.whole if identifier_boundaries is not None else None)
+        case _ as invalid:
+            raise ValueError(f'Unsupported region type: {type(invalid)}')
     return RangeSpec.EMPTY
 
 

src/text_manipulation/range_spec.py

@@ -11,11 +11,12 @@
 
 import re
 from collections.abc import Sequence
-from typing import NamedTuple
+from typing import NamedTuple, TypeAlias
 from functools import total_ordering
 
 
 from cedarscript_ast_parser import Marker, RelativeMarker, RelativePositionType, MarkerType, BodyOrWhole
+
 from .indentation_kit import get_line_indent_count
 
 MATCH_TYPES = ('exact', 'stripped', 'normalized', 'partial')
@@ -43,20 +44,43 @@ def __str__(self):
         return (f'{self.start}:{self.end}' if self.as_index is None else f'%{self.as_index}') + f'@{self.indent}'
 
     def __lt__(self, other):
-        """Compare if this range is strictly before another range."""
-        return self.end < other.start
+        """Compare if this range is strictly before another range or int."""
+        match other:
+            case int():
+                return self.end <= other
+            case RangeSpec():
+                return self.end <= other.start
 
     def __le__(self, other):
         """Compare if this range is before or adjacent to another range."""
-        return self.end <= other.start
+        match other:
+            case int():
+                return self.end <= other - 1
+            case RangeSpec():
+                return self.end <= other.start - 1
 
     def __gt__(self, other):
         """Compare if this range is strictly after another range."""
-        return self.start > other.end
+        match other:
+            case int():
+                return self.start > other
+            case RangeSpec():
+                return self.start >= other.end
 
     def __ge__(self, other):
         """Compare if this range is after or adjacent to another range."""
-        return self.start >= other.end
+        match other:
+            case int():
+                return self.start >= other
+            case RangeSpec():
+                return self.start >= other.end - 1
+
+    def __contains__(self, item):
+        match item:
+            case int():
+                return self.start <= item < self.end
+            case RangeSpec():
+                return self == RangeSpec.EMPTY or item != RangeSpec.EMPTY and self.start <= item.start and item.end <= self.end
 
     @property
     def line_count(self):
@@ -235,6 +259,12 @@ def from_line_marker(
 RangeSpec.EMPTY = RangeSpec(0, -1, 0)
 
 
+class ParentInfo(NamedTuple):
+    parent_name: str
+    parent_type: str
+
+ParentRestriction: TypeAlias = RangeSpec | str | None
+
 class IdentifierBoundaries(NamedTuple):
     """
     Represents the boundaries of an identifier in code, including its whole range and body range.
@@ -251,6 +281,7 @@ class IdentifierBoundaries(NamedTuple):
     body: RangeSpec | None = None
     docstring: RangeSpec | None = None
     decorators: list[RangeSpec] = []
+    parents: list[ParentInfo] = []
 
     def __str__(self):
         return f'IdentifierBoundaries({self.whole} (BODY: {self.body}) )'
@@ -270,6 +301,18 @@ def end_line(self) -> int:
         """Return the 1-indexed end line of the whole identifier."""
         return self.whole.end
 
+    def match_parent(self, parent_restriction: ParentRestriction) -> bool:
+        match parent_restriction:
+            case None:
+                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 _:
+                raise ValueError(f'Invalid parent restriction: {parent_restriction}')
+
     def location_to_search_range(self, location: BodyOrWhole | RelativePositionType) -> RangeSpec:
         """
         Convert a location specifier to a RangeSpec for searching.