Test corpus

elifarley · elifarley · commit 7356abbf981c · 2024-10-23T01:52:43.000-03:00
diff --git a/src/cedarscript_editor/__init__.py b/src/cedarscript_editor/__init__.py
@@ -7,7 +7,7 @@
     "__version__", "find_commands", "CEDARScriptEditor"
 ]
 
-
+# TODO Move to cedarscript-ast-parser
 def find_commands(content: str):
     # Regex pattern to match CEDARScript blocks
     pattern = r'```CEDARScript\n(.*?)```'
diff --git a/src/cedarscript_editor/cedarscript_editor.py b/src/cedarscript_editor/cedarscript_editor.py
@@ -1,5 +1,6 @@
 import os
 from collections.abc import Sequence
+from pathlib import Path
 
 from cedarscript_ast_parser import Command, RmFileCommand, MvFileCommand, UpdateCommand, \
     SelectCommand, IdentifierFromFile, Segment, Marker, MoveClause, DeleteClause, \
@@ -65,7 +66,7 @@ def __init__(self, command_ordinal: int, description: str):
 
 class CEDARScriptEditor:
     def __init__(self, root_path: os.PathLike):
-        self.root_path = os.path.abspath(root_path)
+        self.root_path = Path(os.path.abspath(root_path))
         print(f'[{self.__class__.__name__}] root: {self.root_path}')
 
     # TODO Add 'target_search_range: RangeSpec' parameter
@@ -257,14 +258,14 @@ def _rm_command(self, cmd: RmFileCommand):
     def _delete_function(self, cmd):  # TODO
         file_path = os.path.join(self.root_path, cmd.file_path)
 
-    # def _create_command(self, cmd: CreateCommand):
-    #     file_path = os.path.join(self.root_path, cmd.file_path)
-    #
-    #     os.makedirs(os.path.dirname(file_path), exist_ok=False)
-    #     with open(file_path, 'w') as file:
-    #         file.write(content)
-    #
-    #     return f"Created file: {command['file']}"
+        def _create_command(self, cmd: CreateCommand):
+            file_path = os.path.join(self.root_path, cmd.file_path)
+            
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, 'w') as file:
+                file.write(cmd.content)
+            
+            return f"Created file: {cmd.file_path}"
 
 
 def find_index_range_for_region(region: BodyOrWhole | Marker | Segment | RelativeMarker,
diff --git a/src/cedarscript_editor/tree_sitter_identifier_finder.py b/src/cedarscript_editor/tree_sitter_identifier_finder.py
@@ -24,13 +24,18 @@ def find_identifier(source_info: tuple[str, str | Sequence[str]], search_rage: R
 
 def _select_finder(file_path: str, source: str, search_range: RangeSpec = RangeSpec.EMPTY) -> IdentifierFinder:
     langstr = filename_to_lang(file_path)
-    language = get_language(langstr)
-    parser = get_parser(langstr)
-    _log.info(f"[select_finder] Selected {language}")
+    match langstr:
+        case None:
+            language = None
+            query_info = None
+            _log.info(f"[select_finder] NO LANGUAGE for `{file_path}`")
+        case _:
+            query_info = LANG_TO_TREE_SITTER_QUERY[langstr]
+            language = get_language(langstr)
+            _log.info(f"[select_finder] Selected {language}")
+            tree = get_parser(langstr).parse(bytes(source, "utf-8"))
 
-    tree = parser.parse(bytes(source, "utf-8"))
     source = source.splitlines()
-    query_info = LANG_TO_TREE_SITTER_QUERY[langstr]
 
     def find_by_marker(mos: Marker | Segment) -> IdentifierBoundaries | RangeSpec | None:
         match mos:
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/corpus/test-1/chat.xml b/tests/corpus/test-1/chat.xml
@@ -0,0 +1,38 @@
+<train>
+<user>
+Refactor the `_candidate` method to be a stand alone, top level function.
+</user>
+<assistant>
+Here's my plan to implement the requested changes:
+1. Move the `_candidate()` method from the `A` class, placing it at the top level, just before the line where its class starts;
+2. Update the copied function to remove references to `self`;
+3. Update ALL call sites of the method `_candidate()` to call the new top-level function with the same name;
+
+Here's the CEDARScript script:
+
+```CEDARScript
+-- 1. Move the `_candidate()` method from the `A` class, placing it at the top level, just before the line where its class starts
+UPDATE CLASS "A" -- As method `calc1` exists in more than 1 class, we specify which one we want to reference
+  FROM FILE "main.py"
+MOVE FUNCTION "_candidate"
+INSERT BEFORE CLASS "A"
+  RELATIVE INDENTATION 0;
+
+-- 2. Update the copied function to remove references to `self`
+UPDATE FUNCTION "_candidate"
+  FROM FILE "main.py"
+REPLACE LINE "def _candidate(self, a, b, c):"
+WITH CONTENT '''
+@0:def _candidate(a, b, c):
+''';
+
+-- 3. Update ALL call sites of the method `_candidate()` to call the new top-level function with the same name
+UPDATE FUNCTION "_check"
+  FROM FILE "main.py"
+REPLACE LINE 'self._candidate(' -- There's only 1 call site and this line marker is unambiguous, so it's more concise to just replace a LINE instead of a SEGMENT
+WITH CONTENT '''
+@0:_candidate(
+''';
+```
+</assistant>
+</train>
diff --git a/tests/corpus/test-1/expected.main.py b/tests/corpus/test-1/expected.main.py
@@ -0,0 +1,20 @@
+def _candidate(a, b, c):
+    return a
+class A:
+    def _calc(self, a):
+        return a
+    def _check(self, a: int, b, c):
+        if a > 0:
+            return self._calc(
+                "a thing or two"
+            )
+        else:
+            return list(
+                self._calc(
+                    _candidate(
+                        a, "string 1", 4
+                    )
+                    for index, item in enumerate(a.the_elements)
+                )
+            )
+
diff --git a/tests/corpus/test-1/main.py b/tests/corpus/test-1/main.py
@@ -0,0 +1,20 @@
+class A:
+    def _calc(self, a):
+        return a
+    def _check(self, a: int, b, c):
+        if a > 0:
+            return self._calc(
+                "a thing or two"
+            )
+        else:
+            return list(
+                self._calc(
+                    self._candidate(
+                        a, "string 1", 4
+                    )
+                    for index, item in enumerate(a.the_elements)
+                )
+            )
+
+    def _candidate(self, a, b, c):
+        return a
diff --git a/tests/corpus/update.file.delete.line/chat.xml b/tests/corpus/update.file.delete.line/chat.xml
@@ -0,0 +1,6 @@
+<no-train>
+```CEDARScript
+UPDATE FILE "main.something" DELETE LINE 'risus cursus'
+UPDATE FILE "main.something" DELETE LINE "etiam a"
+```
+</no-train>
diff --git a/tests/corpus/update.file.delete.line/expected.main.something b/tests/corpus/update.file.delete.line/expected.main.something
@@ -0,0 +1,13 @@
+Lorem ipsum odor amet,
+  consectetuer adipiscing elit.
+Ligula vestibulum semper sagittis sapien class.
+Dolor nascetur litora feugiat urna,
+    natoque venenatis fames.
+    At elementum urna suspendisse
+    himenaeos massa dui.
+        Vivamus in
+            ac vulputate dolor;
+                amet pulvinar.
+                    Fames tempus habitasse
+                      parturient
+                    mollis.
diff --git a/tests/corpus/update.file.delete.line/main.something b/tests/corpus/update.file.delete.line/main.something
@@ -0,0 +1,15 @@
+Lorem ipsum odor amet,
+  consectetuer adipiscing elit.
+Ligula vestibulum semper sagittis sapien class.
+Dolor nascetur litora feugiat urna,
+    natoque venenatis fames.
+    At elementum urna suspendisse
+    himenaeos massa dui.
+        Vivamus in
+          risus cursus
+            ac vulputate dolor;
+                amet pulvinar.
+                    Fames tempus habitasse
+                      etiam a
+                      parturient
+                    mollis.
diff --git a/tests/test_corpus.py b/tests/test_corpus.py
@@ -0,0 +1,88 @@
+import os
+import shutil
+import tempfile
+import pytest
+from pathlib import Path
+
+from cedarscript_editor import find_commands, CEDARScriptEditor
+
+
+def get_test_cases() -> list[str]:
+    """Get all test cases from tests/corpus directory.
+    
+    Returns:
+    list[str]: Names of all test case directories in the corpus
+    """
+    corpus_dir = Path(__file__).parent / 'corpus'
+    return [d.name for d in corpus_dir.iterdir() if d.is_dir()]
+
+
+@pytest.fixture
+def editor(tmp_path_factory):
+    """Fixture providing a CEDARScriptEditor instance with a temporary directory.
+    
+    The temporary directory is preserved if the test fails, to help with debugging.
+    It is automatically cleaned up if the test passes.
+    """
+    # Create temp dir under the project's 'out' directory
+    out_dir = Path(__file__).parent.parent / 'out'
+    out_dir.mkdir(exist_ok=True)
+    temp_dir = Path(tempfile.mkdtemp(prefix='test-', dir=out_dir))
+    editor = CEDARScriptEditor(temp_dir)
+    yield editor
+    # Directory will be preserved if test fails (pytest handles this automatically)
+    if not hasattr(editor, "_failed"):  # No failure occurred
+        shutil.rmtree(temp_dir)
+
+
+@pytest.mark.parametrize('test_case', get_test_cases())
+def test_corpus(editor: CEDARScriptEditor, test_case: str):
+    """Test CEDARScript commands from chat.xml files in corpus."""
+    try:
+        corpus_dir = Path(__file__).parent / 'corpus'
+        test_dir = corpus_dir / test_case
+
+        # Create scratch area for this test
+        # Copy all files from test dir to scratch area, except chat.xml and expected.*
+        def copy_files(src_dir: Path, dst_dir: Path):
+            for src in src_dir.iterdir():
+                if src.name == 'chat.xml' or src.name.startswith('expected.'):
+                    continue
+                dst = dst_dir / src.name
+                if src.is_dir():
+                    dst.mkdir(exist_ok=True)
+                    copy_files(src, dst)
+                else:
+                    shutil.copy2(src, dst)
+
+        copy_files(test_dir, editor.root_path)
+
+        # Read chat.xml
+        chat_xml = (test_dir / 'chat.xml').read_text()
+
+        # Find and apply commands
+        commands = list(find_commands(chat_xml))
+        assert commands, "No commands found in chat.xml"
+        editor.apply_commands(commands)
+
+        # For each file in the scratch directory, check its expected version
+        def check_expected_files(dir_path: Path):
+            for path in dir_path.iterdir():
+                if path.is_dir():
+                    check_expected_files(path)
+                else:
+                    # Find corresponding expected file in test directory
+                    rel_path = path.relative_to(editor.root_path)
+                    expected_file = test_dir / f"expected.{rel_path}"
+                    assert expected_file.exists(), f"Expected file not found: {expected_file}"
+
+                    expected_content = expected_file.read_text()
+                    result_content = path.read_text()
+                    assert result_content.strip() == expected_content.strip(), \
+                        f"Output does not match expected content for {rel_path}"
+
+        check_expected_files(editor.root_path)
+
+    except Exception:
+        editor._failed = True  # Mark as failed to preserve temp directory
+        raise

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`"__version__", "find_commands", "CEDARScriptEditor"`
`8`	`8`	`]`
`9`	`9`
`10`		`-`
	`10`	`+# TODO Move to cedarscript-ast-parser`
`11`	`11`	`def find_commands(content: str):`
`12`	`12`	`# Regex pattern to match CEDARScript blocks`
`13`	`13`	pattern = r'```CEDARScript\n(.*?)```'