Inline snapshots are working (#354)

Author: nedtwigg

python/example-pytest-selfie/tests/simple_inline_test.py

@@ -8,7 +8,6 @@
 # def test_read_fail():
 #     expect_selfie("A").to_be("B")
 
-"""
+
 def test_write():
     expect_selfie("B").to_be_TODO()
-"""

python/selfie-lib/selfie_lib/CommentTracker.py

@@ -32,7 +32,7 @@ def paths_with_once(self) -> Iterable[TypedPath]:
             ]
 
     def hasWritableComment(self, call: CallStack, layout: SnapshotFileLayout) -> bool:
-        path = layout.sourcefile_for_call(call)
+        path = layout.sourcefile_for_call(call.location)
         with self.lock:
             if path in self.cache:
                 comment = self.cache[path]

python/selfie-lib/selfie_lib/SnapshotSystem.py

@@ -109,7 +109,7 @@ def can_write(self, is_todo: bool, call: CallStack, system: SnapshotSystem) -> b
         elif self == Mode.readonly:
             if system.source_file_has_writable_comment(call):
                 layout = system.layout
-                path = layout.sourcefile_for_call(call)
+                path = layout.sourcefile_for_call(call.location)
                 comment, line = CommentTracker.commentString(path)
                 raise system.fs.assert_failed(
                     f"Selfie is in readonly mode, so `{comment}` is illegal at {call.location.with_line(line).ide_link(layout)}"

python/selfie-lib/selfie_lib/SourceFile.py

@@ -1,3 +1,4 @@
+import re
 from .Slice import Slice
 from .Literals import Language, LiteralFormat, LiteralValue
 from .EscapeLeadingWhitespace import EscapeLeadingWhitespace
@@ -9,15 +10,15 @@ class SourceFile:
 
     def __init__(self, filename: str, content: str) -> None:
         self.__unix_newlines: bool = "\r" not in content
-        self.__content_slice: Slice = Slice(content.replace("\r\n", "\n"))
+        self._content_slice: Slice = Slice(content.replace("\r\n", "\n"))
         self.__language: Language = Language.from_filename(filename)
         self.__escape_leading_whitespace = EscapeLeadingWhitespace.appropriate_for(
-            self.__content_slice.__str__()
+            self._content_slice.__str__()
         )
 
     def remove_selfie_once_comments(self):
         # Split content into lines
-        lines = self.__content_slice.__str__().split("\n")
+        lines = self._content_slice.__str__().split("\n")
 
         # Create a new list of lines, excluding lines containing '# selfieonce' or '#selfieonce'
         new_lines = []
@@ -39,28 +40,30 @@ def remove_selfie_once_comments(self):
         new_content = "\n".join(new_lines)
 
         # Update the content slice with new content
-        self.__content_slice = Slice(new_content)
+        self._content_slice = Slice(new_content)
 
         if not self.__unix_newlines:
-            self.__content_slice = Slice(new_content.replace("\n", "\r\n"))
+            self._content_slice = Slice(new_content.replace("\n", "\r\n"))
 
     @property
     def as_string(self) -> str:
         return (
-            self.__content_slice.__str__()
+            self._content_slice.__str__()
             if self.__unix_newlines
-            else self.__content_slice.__str__().replace("\n", "\r\n")
+            else self._content_slice.__str__().replace("\n", "\r\n")
         )
 
     class ToBeLiteral:
         def __init__(
             self,
+            parent: "SourceFile",
             dot_fun_open_paren: str,
             function_call_plus_arg: Slice,
             arg: Slice,
             language: Language,
             escape_leading_whitespace: EscapeLeadingWhitespace,
         ) -> None:
+            self.__parent = parent
             self.__dot_fun_open_paren = dot_fun_open_paren
             self.__function_call_plus_arg = function_call_plus_arg
             self.__arg = arg
@@ -92,16 +95,19 @@ def set_literal_and_get_newline_delta(self, literal_value: LiteralValue) -> int:
                 )
             existing_newlines = self.__function_call_plus_arg.count("\n")
             new_newlines = encoded.count("\n")
-            self.__content_slice = self.__function_call_plus_arg.replaceSelfWith(
-                f"{self.__dot_fun_open_paren}{encoded})"
+            self.__parent._content_slice = Slice(
+                self.__function_call_plus_arg.replaceSelfWith(
+                    f"{self.__dot_fun_open_paren}{encoded})"
+                )
             )
+
             return new_newlines - existing_newlines
 
         def parse_literal(self, literal_format: LiteralFormat) -> Any:
             return literal_format.parse(self.__arg.__str__(), self.__language)
 
     def find_on_line(self, to_find: str, line_one_indexed: int) -> Slice:
-        line_content = self.__content_slice.unixLine(line_one_indexed)
+        line_content = self._content_slice.unixLine(line_one_indexed)
         idx = line_content.indexOf(to_find)
         if idx == -1:
             raise AssertionError(
@@ -115,12 +121,12 @@ def find_on_line(self, to_find: str, line_one_indexed: int) -> Slice:
     def replace_on_line(self, line_one_indexed: int, find: str, replace: str) -> None:
         assert "\n" not in find
         assert "\n" not in replace
-        line_content = self.__content_slice.unixLine(line_one_indexed).__str__()
+        line_content = self._content_slice.unixLine(line_one_indexed).__str__()
         new_content = line_content.replace(find, replace)
-        self.__content_slice = Slice(self.__content_slice.replaceSelfWith(new_content))
+        self._content_slice = Slice(self._content_slice.replaceSelfWith(new_content))
 
     def parse_to_be_like(self, line_one_indexed: int) -> ToBeLiteral:
-        line_content = self.__content_slice.unixLine(line_one_indexed)
+        line_content = self._content_slice.unixLine(line_one_indexed)
         dot_fun_open_paren = None
 
         for to_be_like in TO_BE_LIKES:
@@ -137,24 +143,24 @@ def parse_to_be_like(self, line_one_indexed: int) -> ToBeLiteral:
         dot_function_call = dot_function_call_in_place + line_content.startIndex
         arg_start = dot_function_call + len(dot_fun_open_paren)
 
-        if self.__content_slice.__len__() == arg_start:
+        if self._content_slice.__len__() == arg_start:
             raise AssertionError(
                 f"Appears to be an unclosed function call `{dot_fun_open_paren}` "
                 f"on line {line_one_indexed}"
             )
-        while self.__content_slice[arg_start].isspace():
+        while self._content_slice[arg_start].isspace():
             arg_start += 1
-            if self.__content_slice.__len__() == arg_start:
+            if self._content_slice.__len__() == arg_start:
                 raise AssertionError(
                     f"Appears to be an unclosed function call `{dot_fun_open_paren}` "
                     f"on line {line_one_indexed}"
                 )
 
         end_arg = -1
         end_paren = 0
-        if self.__content_slice[arg_start] == '"':
-            if self.__content_slice[arg_start].startswith(self.TRIPLE_QUOTE):
-                end_arg = self.__content_slice.indexOf(
+        if self._content_slice[arg_start] == '"':
+            if self._content_slice[arg_start].startswith(self.TRIPLE_QUOTE):
+                end_arg = self._content_slice.indexOf(
                     self.TRIPLE_QUOTE, arg_start + len(self.TRIPLE_QUOTE)
                 )
                 if end_arg == -1:
@@ -168,11 +174,11 @@ def parse_to_be_like(self, line_one_indexed: int) -> ToBeLiteral:
             else:
                 end_arg = arg_start + 1
                 while (
-                    self.__content_slice[end_arg] != '"'
-                    or self.__content_slice[end_arg - 1] == "\\"
+                    self._content_slice[end_arg] != '"'
+                    or self._content_slice[end_arg - 1] == "\\"
                 ):
                     end_arg += 1
-                    if end_arg == self.__content_slice.__len__():
+                    if end_arg == self._content_slice.__len__():
                         raise AssertionError(
                             f'Appears to be an unclosed string literal `"` '
                             f"on line {line_one_indexed}"
@@ -181,37 +187,44 @@ def parse_to_be_like(self, line_one_indexed: int) -> ToBeLiteral:
                 end_paren = end_arg
         else:
             end_arg = arg_start
-            while not self.__content_slice[end_arg].isspace():
-                if self.__content_slice[end_arg] == ")":
+            while not self._content_slice[end_arg].isspace():
+                if self._content_slice[end_arg] == ")":
                     break
                 end_arg += 1
-                if end_arg == self.__content_slice.__len__():
+                if end_arg == self._content_slice.__len__():
                     raise AssertionError(
                         f"Appears to be an unclosed numeric literal "
                         f"on line {line_one_indexed}"
                     )
             end_paren = end_arg
-        while self.__content_slice[end_paren] != ")":
-            if not self.__content_slice[end_paren].isspace():
+        while self._content_slice[end_paren] != ")":
+            if not self._content_slice[end_paren].isspace():
                 raise AssertionError(
                     f"Non-primitive literal in `{dot_fun_open_paren}` starting at "
                     f"line {line_one_indexed}: error for character "
-                    f"`{self.__content_slice[end_paren]}` on line "
-                    f"{self.__content_slice.baseLineAtOffset(end_paren)}"
+                    f"`{self._content_slice[end_paren]}` on line "
+                    f"{self._content_slice.baseLineAtOffset(end_paren)}"
                 )
             end_paren += 1
-            if end_paren == self.__content_slice.__len__():
+            if end_paren == self._content_slice.__len__():
                 raise AssertionError(
                     f"Appears to be an unclosed function call `{dot_fun_open_paren}` "
                     f"starting at line {line_one_indexed}"
                 )
         return self.ToBeLiteral(
+            self,
             dot_fun_open_paren.replace("_TODO", ""),
-            self.__content_slice.subSequence(dot_function_call, end_paren + 1),
-            self.__content_slice.subSequence(arg_start, end_arg),
+            self._content_slice.subSequence(dot_function_call, end_paren + 1),
+            self._content_slice.subSequence(arg_start, end_arg),
             self.__language,
             self.__escape_leading_whitespace,
         )
 
 
-TO_BE_LIKES = [".toBe(", ".toBe_TODO(", ".toBeBase64(", ".toBeBase64_TODO("]
+TO_BE_LIKES = [
+    ".to_be(",
+    ".to_be_TODO(",
+    ".to_be_base64(",
+    ".to_be_base64_TODO(",
+    ".to_be_TODO(",
+]

python/selfie-lib/selfie_lib/WriteTracker.py

@@ -7,7 +7,7 @@
 from functools import total_ordering
 
 from .SourceFile import SourceFile
-from .Literals import LiteralValue
+from .Literals import LiteralValue, LiteralTodoStub
 from .TypedPath import TypedPath
 from .FS import FS
 
@@ -87,8 +87,8 @@ class SnapshotFileLayout:
     def __init__(self, fs: FS):
         self.fs = fs
 
-    def sourcefile_for_call(self, call: CallStack) -> TypedPath:
-        file_path = call.location.file_name
+    def sourcefile_for_call(self, call: CallLocation) -> TypedPath:
+        file_path = call.file_name
         if not file_path:
             raise ValueError("No file path available in CallLocation.")
         return TypedPath(os.path.abspath(Path(file_path)))
@@ -174,8 +174,7 @@ def record(
     ):
         super().recordInternal(call.location, snapshot, call, layout)
 
-        call_stack_from_location = CallStack(call.location, [])
-        file = layout.sourcefile_for_call(call_stack_from_location)
+        file = layout.sourcefile_for_call(call.location)
 
         if snapshot.expected is not None:
             content = SourceFile(file.name, layout.fs.file_read(file))
@@ -197,4 +196,45 @@ def record(
                 )
 
     def persist_writes(self, layout: SnapshotFileLayout):
-        raise NotImplementedError("InlineWriteTracker does not support persist_writes")
+        # Assuming there is at least one write to process
+        if not self.writes:
+            return
+
+        # Sorting writes based on file name and line number
+        sorted_writes = sorted(
+            self.writes.values(),
+            key=lambda x: (x.call_stack.location.file_name, x.call_stack.location.line),
+        )
+
+        # Initialize from the first write
+        first_write = sorted_writes[0]
+        current_file = layout.sourcefile_for_call(first_write.call_stack.location)
+        content = SourceFile(current_file.name, layout.fs.file_read(current_file))
+        delta_line_numbers = 0
+
+        for write in sorted_writes:
+            # Determine the file path for the current write
+            file_path = layout.sourcefile_for_call(write.call_stack.location)
+            # If we switch to a new file, write changes to the disk for the previous file
+            if file_path != current_file:
+                layout.fs.file_write(current_file, content.as_string)
+                current_file = file_path
+                content = SourceFile(
+                    current_file.name, layout.fs.file_read(current_file)
+                )
+                delta_line_numbers = 0
+
+            # Calculate the line number taking into account changes that shifted line numbers
+            line = write.call_stack.location.line + delta_line_numbers
+            if isinstance(write.snapshot.format, LiteralTodoStub):
+                content.replace_on_line(line, ".${kind.name}_TODO(", ".${kind.name}(")
+            else:
+                to_be_literal = content.parse_to_be_like(line)
+                # Attempt to set the literal value and adjust for line shifts due to content changes
+                literal_change = to_be_literal.set_literal_and_get_newline_delta(
+                    write.snapshot
+                )
+                delta_line_numbers += literal_change
+
+        # Final write to disk for the last file processed
+        layout.fs.file_write(current_file, content.as_string)

python/selfie-lib/tests/Slice_test.py

@@ -12,3 +12,10 @@ def test_unixLine():
     assert str(one_two_three.unixLine(4)) == ""
     assert str(one_two_three.unixLine(5)) == "FOURTH"
     assert str(one_two_three.unixLine(6)) == ""
+
+
+def test_replace_self():
+    undertest = Slice("ABC")
+    justB = undertest.subSequence(1, 2)
+    assert str(justB) == "B"
+    assert justB.replaceSelfWith("D") == "ADC"