More improvements and fixes

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.3",
+    "cedarscript-ast-parser>=0.2.4",
     "rope>=1.13.0"
 ]
 requires-python = ">=3.11"

src/cedarscript_editor/__init__.py

@@ -18,11 +18,11 @@ def find_commands(content: str):
     pattern = r'```CEDARScript\n(.*?)```'
     cedar_script_blocks = re.findall(pattern, content, re.DOTALL)
     print(f'[find_cedar_commands] Script block count: {len(cedar_script_blocks)}')
-    if len(cedar_script_blocks) == 0:
+    if len(cedar_script_blocks) == 0 and not content.strip().endswith('<NOCEDARSCRIPT/>'):
         raise ValueError(
             "No CEDARScript block detected. "
             "Perhaps you forgot to enclose the block using ```CEDARScript and ``` ? "
-            "Or was that intentional? If so, just write tag <NOSCRIPT/> and nothing else."
+            "Or was that intentional? If so, just write tag <NOCEDARSCRIPT/> as the last line"
         )
     cedarscript_parser = CEDARScriptASTParser()
     for cedar_script in cedar_script_blocks:

src/cedarscript_editor/cedarscript_editor.py

@@ -33,7 +33,7 @@ def __init__(self, command_ordinal: int, description: str):
 
             previous_cmd_notes = (
                 f", bearing in mind the file was updated and now contains all changes expressed in "
-                f"commands {items}"
+                f"commands {items}."
             )
             if 'syntax' in description.casefold():
                 probability_indicator = "most probably"
@@ -43,10 +43,11 @@ def __init__(self, command_ordinal: int, description: str):
             note = (
                 f"<note>*ALL* commands *before* command #{command_ordinal} "
                 "were applied and *their changes are already committed*. "
-                f"Re-read the file to catch up with the applied changes."
+                f"So, it's *CRUCIAL* to re-analyze the file to catch up with the applied changes "
+                "and understand what still needs to be done. "
                 f"ATTENTION: The previous command (#{command_ordinal - 1}) {probability_indicator} "
                 f"caused command #{command_ordinal} to fail "
-                f"due to changes that left the file in an invalid state (check that by re-analyzing the file!)</note>"
+                f"due to changes that left the file in an invalid state (check that by re-reading the file!)</note>"
             )
         super().__init__(
             f"<error-details><error-location>COMMAND #{command_ordinal}</error-location>{note}"
@@ -57,7 +58,7 @@ def __init__(self, command_ordinal: int, description: str):
             "the state at which the file was left (saying what needs to be done now), "
             f"then write new commands that will fix the problem{previous_cmd_notes} "
             "(you'll get a one-million dollar tip if you get it right!) "
-            "Use descriptive comment before each command.</suggestion></error-details>"
+            "Use descriptive comment before each command; If showing CEDARScript commands to the user, *DON'T* enclose them in ```CEDARSCript and ``` otherwise they will be executed!</suggestion></error-details>"
         )
 
 
@@ -197,26 +198,34 @@ def identifier_resolver(m: Marker):
                         )
                         dest_indent = dest_range.indent
                         content = move_src_range.read(lines)
-                        count = dest_indent + (relindent or 0)
+                        shift_count = dest_indent + (relindent or 0)
                         content = IndentationInfo.from_content(content).shift_indentation(
-                            content, count
+                            content, shift_count
                         )
                     case _:
                         raise ValueError(f'Invalid content: {content}')
 
-        self._apply_action(action, lines, search_range, content)
+        self._apply_action(action, lines, search_range, content, range_spec_to_delete=move_src_range)
 
         write_file(file_path, lines)
 
         return f"Updated {target if target else 'file'} in {file_path}\n  -> {action}"
 
     @staticmethod
-    def _apply_action(action: EditingAction, lines: Sequence[str], range_spec: RangeSpec, content: str | None = None):
+    def _apply_action(
+        action: EditingAction, lines: Sequence[str], range_spec: RangeSpec, content: str | None = None,
+        range_spec_to_delete: RangeSpec | None = None
+    ):
         match action:
 
             case MoveClause(insert_position=insert_position, to_other_file=other_file, relative_indentation=relindent):
                 # TODO Move from 'lines' to the same file or to 'other_file'
-                range_spec.write(content, lines)
+                if range_spec <= range_spec_to_delete:
+                    range_spec_to_delete.delete(lines)
+                    range_spec.write(content, lines)
+                else:
+                    range_spec.write(content, lines)
+                    range_spec_to_delete.delete(lines)
 
             case DeleteClause():
                 range_spec.delete(lines)
@@ -339,8 +348,8 @@ def restrict_search_range_for_marker(
                         case InsertClause():
                             if action.insert_position.qualifier == RelativePositionType.BEFORE:
                                 search_range = search_range.inc()
-                        case DeleteClause():
-                            search_range = search_range.set_length(1)
+                        case RegionClause():
+                            search_range = search_range.set_line_count(1)
                 case _:
                     identifier_boundaries = identifier_resolver(marker)
                     if not identifier_boundaries:

src/cedarscript_editor/python_identifier_finder.py

@@ -60,14 +60,14 @@ def find_python_identifier(root_path: str, file_name: str, source: str, marker:
         return None
     if candidate_count > 1 and marker.offset is None:
         raise ValueError(
-            f"There are {candidate_count} functions named `{marker.value}` in file `{file_name}`. "
-            f"Use `OFFSET <0..{candidate_count - 1}>` to determine how many to skip. "
+            f"There are {candidate_count} {marker.type} identifiers named `{marker.value}`. "
+            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}`"
         )
     if marker.offset and marker.offset >= candidate_count:
         raise ValueError(
-            f"There are only {candidate_count} functions named `{marker.value} in file `{file_name}`, "
-            f"but 'offset' was set to {marker.offset} (you can only skip {candidate_count - 1} functions)"
+            f"There are only {candidate_count} {marker.type} identifiers named `{marker.value}`, "
+            f"but 'OFFSET' was set to {marker.offset} (you can skip at most {candidate_count - 1} of those)"
         )
     candidates.sort(key=lambda x: x.start_line)
     result: IdentifierBoundaries = get_by_offset(candidates, marker.offset or 0)

src/text_manipulation/range_spec.py

@@ -1,13 +1,15 @@
 import re
 from collections.abc import Sequence
 from typing import NamedTuple
+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')
 
-
+@total_ordering
 class RangeSpec(NamedTuple):
     start: int
     end: int
@@ -16,18 +18,31 @@ class RangeSpec(NamedTuple):
     def __str__(self):
         return (f'{self.start}:{self.end}' if self.as_index is None else f'%{self.as_index}') + f'@{self.indent}'
 
-    def __len__(self):
+    def __lt__(self, other):
+        return self.end < other.start
+
+    def __le__(self, other):
+        return self.end <= other.start
+
+    def __gt__(self, other):
+        return self.start > other.end
+
+    def __ge__(self, other):
+        return self.start >= other.end
+
+    @property
+    def line_count(self):
         return self.end - self.start
 
     @property
     def as_index(self) -> int | None:
-        return None if len(self) else self.start
+        return None if self.line_count else self.start
 
     @property
     def collapsed(self):
         return self.set_length(0)
 
-    def set_length(self, range_len: int):
+    def set_line_count(self, range_len: int):
         return self._replace(end=self.start + range_len)
 
     def inc(self, count: int = 1):
@@ -137,7 +152,22 @@ def from_line_marker(
 
         offset = search_term.offset or 0
         for match_type in MATCH_TYPES:
-            if offset < len(matches[match_type]):
+            match_type_count = len(matches[match_type])
+            if search_term.offset is None and match_type_count > 1:
+                raise ValueError(
+                    f"There are {match_type_count} lines matching `{search_term.value}`. "
+                    f"Suggestion: Try using a different line as marker (a couple lines before or after the current one)."
+                    # f"Add an `OFFSET` (after the line marker) and a number between 0 and {match_type_count - 1} to determine how many to skip. "
+                    # f"Example to reference the *last* one of those: `LINE '{search_term.value.strip()}' OFFSET {match_type_count - 1}`"
+                    # ' (See `offset_clause` in `<grammar.js>` for details on OFFSET)'
+                )
+            if match_type_count and (search_term.offset or 0) >= match_type_count:
+                raise ValueError(
+                    f"There are only {match_type_count} lines matching `{search_term.value}`, "
+                    f"but 'OFFSET' was set to {search_term.offset} (you can skip at most {match_type_count - 1} of those)"
+                )
+
+            if offset < match_type_count:
                 index, reference_indent = matches[match_type][offset]
                 match match_type:
                     case 'normalized':

src/text_manipulation/text_editor_kit.py

@@ -89,8 +89,9 @@ def segment_to_search_range(
     )
 
     start_index_for_end_marker = start_match_result.as_index
-    if start_relpos.qualifier == RelativePositionType.AFTER:
-        start_index_for_end_marker += -1
+    match start_relpos:
+        case RelativeMarker(qualifier=RelativePositionType.AFTER):
+            start_index_for_end_marker += -1
     end_match_result = RangeSpec.from_line_marker(lines, end_relpos, RangeSpec(
         start_index_for_end_marker, search_range.end, start_match_result.indent
     ))