Correcting the 'Before' stacking effect

MementoRC · MementoRC · commit 2fed8a4be766 · 2022-12-26T16:43:59.000-06:00
Adding consideration for negative offset in graph_access.py
diff --git a/refactor/actions.py b/refactor/actions.py
@@ -17,7 +17,9 @@
 __all__ = [
     "BaseAction",
     "InsertAfter",
+    "InsertBefore",
     "LazyInsertAfter",
+    "LazyInsertBefore",
     "LazyReplace",
     "Replace",
     "Erase",
@@ -195,7 +197,6 @@ def _stack_effect(self) -> tuple[ast.AST, int]:
         return (self.node, 1)
 
 
-@_hint("deprecated_alias", "NewStatementAction")
 @dataclass
 class LazyInsertBefore(_LazyActionMixin[ast.stmt, ast.stmt]):
     """Inserts the re-synthesized version :py:meth:`LazyInsertBefore.build`'s
@@ -217,25 +218,18 @@ def apply(self, context: Context, source: str) -> str:
 
         replacement = split_lines(context.unparse(self.build()))
         replacement.apply_indentation(indentation, start_prefix=start_prefix)
+        replacement[-1] += lines._newline_type
 
         original_node_start = cast(int, self.node.lineno)
-        if lines[original_node_start].endswith(lines._newline_type):
-            replacement[-1] += lines._newline_type
-        else:
-            # If the original anchor's last line doesn't end with a newline,
-            # then we need to also prevent our new source from ending with
-            # a newline.
-            replacement[0] = lines._newline_type + replacement[0]
-
         for line in reversed(replacement):
             lines.insert(original_node_start - 1, line)
 
         return lines.join()
 
     def _stack_effect(self) -> tuple[ast.AST, int]:
-        # Adding a statement right after the node will need to be reflected
+        # Adding a statement right before the node will need to be reflected
         # in the block.
-        return (self.node, 1)
+        return (self.node, -1)
 
 
 @dataclass
@@ -264,7 +258,6 @@ def build(self) -> ast.stmt:
         return self.target
 
 
-@_hint("deprecated_alias", "TargetedNewStatementBeforeAction")
 @dataclass
 class InsertBefore(LazyInsertBefore):
     """Inserts the re-synthesized version of given `target` right after
@@ -341,7 +334,7 @@ def _resynthesize(self, context: Context) -> str:
             return ""
 
     def _stack_effect(self) -> tuple[ast.AST, int]:
-        # Erasing a single node mean positions of all the followinng statements will
+        # Erasing a single node mean positions of all the following statements will
         # need to reduced by 1.
         return (self.node, -1)
 
diff --git a/refactor/internal/graph_access.py b/refactor/internal/graph_access.py
@@ -135,14 +135,14 @@ def shift(self, shifts: list[tuple[GraphPath, int]]) -> GraphPath:
             assert isinstance(target_access, IndexAccess)
 
             # This change might affect the future nodes in this path
-            # but not us.
-            if shifter.index >= target_access.index:
+            # When the requested shift_offset is negative, it does affect us
+            # by the amount of offset
+            if shifter.index + shift_offset >= target_access.index:
                 continue
 
             parts[parts.index(target_access)] = target_access.replace(
-                index=target_access.index + shift_offset
+                index=target_access.index + abs(shift_offset)
             )
-
         return GraphPath(parts)
 
     def execute(self, node: ast.AST) -> ast.AST:
diff --git a/tests/test_actions.py b/tests/test_actions.py
