tests pass, reverse ops implemented

Author: Korijn

patchdiff/__init__.py

@@ -1,4 +1,4 @@
-from .apply import apply
+from .apply import apply, iapply
 from .diff import diff
 
 __version__ = "0.2.0"

patchdiff/apply.py

@@ -4,7 +4,8 @@
 from .types import Diffable
 
 
-def apply(obj: Diffable, patches: List[Dict]) -> Diffable:
+def iapply(obj: Diffable, patches: List[Dict]) -> Diffable:
+    """Apply a set of patches to an object, in-place"""
     for patch in patches:
         ptr = patch["path"]
         op = patch["op"]
@@ -34,3 +35,8 @@ def apply(obj: Diffable, patches: List[Dict]) -> Diffable:
             else:  # add/replace
                 parent[key] = value
     return obj
+
+
+def apply(obj: Diffable, patches: List[Dict]) -> Diffable:
+    """Apply a set of patches to a deep copy of an object"""
+    return iapply(deepcopy(obj), patches)

patchdiff/diff.py

@@ -1,12 +1,12 @@
 from functools import reduce
-from typing import Dict, List, Set
+from typing import Dict, List, Set, Tuple
 
 from .pointer import Pointer
 from .types import Diffable
 
 
-def diff_lists(input: List, output: List, ptr: Pointer) -> List:
-    memory = {(0, 0): {"ops": [], "cost": 0}}
+def diff_lists(input: List, output: List, ptr: Pointer) -> Tuple[List, List]:
+    memory = {(0, 0): {"ops": [], "rops": [], "cost": 0}}
 
     def dist(i, j):
         if (i, j) not in memory:
@@ -17,18 +17,22 @@ def dist(i, j):
                 if i > 0:
                     base = dist(i - 1, j)
                     op = {"op": "remove", "idx": i - 1}
+                    rop = {"op": "add", "idx": i - 1, "value": input[i - 1]}
                     paths.append(
                         {
                             "ops": base["ops"] + [op],
+                            "rops": base["rops"] + [rop],
                             "cost": base["cost"] + 1,
                         }
                     )
                 if j > 0:
                     base = dist(i, j - 1)
                     op = {"op": "add", "idx": j - 1, "value": output[j - 1]}
+                    rop = {"op": "remove", "idx": j - 1}
                     paths.append(
                         {
                             "ops": base["ops"] + [op],
+                            "rops": base["rops"] + [rop],
                             "cost": base["cost"] + 1,
                         }
                     )
@@ -40,18 +44,23 @@ def dist(i, j):
                         "original": input[i - 1],
                         "value": output[j - 1],
                     }
+                    rop = {
+                        "op": "replace",
+                        "idx": i - 1,
+                        "original": output[j - 1],
+                        "value": input[i - 1],
+                    }
                     paths.append(
                         {
                             "ops": base["ops"] + [op],
+                            "rops": base["rops"] + [rop],
                             "cost": base["cost"] + 1,
                         }
                     )
                 step = min(paths, key=lambda a: a["cost"])
             memory[(i, j)] = step
         return memory[(i, j)]
 
-    ops = dist(len(input), len(output))["ops"]
-
     def pad(state, op):
         ops, padding = state
         if op["op"] == "add":
@@ -71,46 +80,54 @@ def pad(state, op):
             return [ops + [full_op], padding - 1]
         else:
             replace_ptr = ptr.append(op["idx"] + padding)
-            replace_ops = diff(op["original"], op["value"], replace_ptr)
+            replace_ops, _ = diff(op["original"], op["value"], replace_ptr)
             return [ops + replace_ops, padding]
 
-    padded_ops, _ = reduce(pad, ops, [[], 0])
+    solution = dist(len(input), len(output))
+    padded_ops, _ = reduce(pad, solution["ops"], [[], 0])
+    padded_rops, _ = reduce(pad, reversed(solution["rops"]), [[], 0])
 
-    return padded_ops
+    return padded_ops, padded_rops
 
 
-def diff_dicts(input: Dict, output: Dict, ptr: Pointer) -> List:
-    ops = []
+def diff_dicts(input: Dict, output: Dict, ptr: Pointer) -> Tuple[List, List]:
+    ops, rops = [], []
     input_keys = set(input.keys())
     output_keys = set(output.keys())
     for key in input_keys - output_keys:
-        ops.append({"op": "remove", "path": ptr.append(key), "key": key})
+        ops.append({"op": "remove", "path": ptr.append(key)})
+        rops.insert(0, {"op": "add", "path": ptr.append(key), "value": output[key]})
     for key in output_keys - input_keys:
         ops.append(
             {
                 "op": "add",
                 "path": ptr.append(key),
-                "key": key,
                 "value": output[key],
             }
         )
+        rops.insert(0, {"op": "remove", "path": ptr.append(key)})
     for key in input_keys & output_keys:
-        ops.extend(diff(input[key], output[key], ptr.append(key)))
-    return ops
+        key_ops, key_rops = diff(input[key], output[key], ptr.append(key))
+        ops.extend(key_ops)
+        key_rops.extend(rops)
+        rops = key_rops
+    return ops, rops
 
 
-def diff_sets(input: Set, output: Set, ptr: Pointer) -> List:
-    ops = []
+def diff_sets(input: Set, output: Set, ptr: Pointer) -> Tuple[List, List]:
+    ops, rops = [], []
     for value in input - output:
-        ops.append({"op": "remove", "path": ptr.append(value), "value": value})
+        ops.append({"op": "remove", "path": ptr.append(value)})
+        rops.insert(0, {"op": "add", "path": ptr.append("-"), "value": value})
     for value in output - input:
-        ops.append({"op": "add", "path": ptr.append(value), "value": value})
-    return ops
+        ops.append({"op": "add", "path": ptr.append("-"), "value": value})
+        rops.insert(0, {"op": "remove", "path": ptr.append(value)})
+    return ops, rops
 
 
-def diff(input: Diffable, output: Diffable, ptr: Pointer = None) -> List:
+def diff(input: Diffable, output: Diffable, ptr: Pointer = None) -> Tuple[List, List]:
     if input == output:
-        return []
+        return [], []
     if ptr is None:
         ptr = Pointer()
     if isinstance(input, list) and isinstance(output, list):
@@ -119,4 +136,6 @@ def diff(input: Diffable, output: Diffable, ptr: Pointer = None) -> List:
         return diff_dicts(input, output, ptr)
     if isinstance(input, set) and isinstance(output, set):
         return diff_sets(input, output, ptr)
-    return [{"op": "replace", "path": ptr, "value": output}]
+    return [{"op": "replace", "path": ptr, "value": output}], [
+        {"op": "replace", "path": ptr, "value": input}
+    ]

patchdiff/pointer.py

@@ -33,7 +33,7 @@ def __str__(self) -> str:
         return "/" + "/".join(escape(str(t)) for t in self.tokens)
 
     def __repr__(self) -> str:
-        return f"Pointer<{str(self)}>"
+        return f"Pointer({repr(self.tokens)})"
 
     def __hash__(self) -> int:
         return hash(self.tokens)
@@ -46,19 +46,19 @@ def __eq__(self, other: "Pointer") -> bool:
     def evaluate(self, obj: Diffable) -> Tuple[Diffable, Hashable, Any]:
         key = ""
         parent = None
-        value = obj
+        cursor = obj
         for key in self.tokens:
-            parent = value
+            parent = cursor
             if isinstance(parent, set):
-                value = key
-                continue
+                break
             if isinstance(parent, list):
-                key = int(key)
+                if key == "-":
+                    break
             try:
-                value = parent[key]
+                cursor = parent[key]
             except KeyError:
                 break
-        return parent, key, value
+        return parent, key, cursor
 
     def append(self, token: Hashable) -> "Pointer":
         """append, creating new Pointer"""

tests/test_apply.py

@@ -2,19 +2,28 @@
 from patchdiff.pointer import Pointer
 
 
-def test_mixed():
+def test_apply():
     a = {
         "a": [5, 7, 9, {"a", "b", "c"}],
         "b": 6,
     }
     b = {"a": [5, 2, 9, {"b", "c"}], "b": 6, "c": 7}
-    ops = diff(a, b)
+    ops, rops = diff(a, b)
 
     assert ops == [
-        {"op": "add", "path": Pointer(["c"]), "key": "c", "value": 7},
+        {"op": "add", "path": Pointer(["c"]), "value": 7},
         {"op": "replace", "path": Pointer(["a", 1]), "value": 2},
-        {"op": "remove", "path": Pointer(["a", 3, "a"]), "value": "a"},
+        {"op": "remove", "path": Pointer(["a", 3, "a"])},
+    ]
+
+    assert rops == [
+        {"op": "add", "path": Pointer(["a", 3, "-"]), "value": "a"},
+        {"op": "replace", "path": Pointer(["a", 1]), "value": 7},
+        {"op": "remove", "path": Pointer(["c"])},
     ]
 
     c = apply(a, ops)
     assert c == b
+
+    d = apply(b, rops)
+    assert a == d

tests/test_diff.py

@@ -5,23 +5,29 @@
 def test_list():
     a = [1, 5, 9, "sdfsdf", "fff"]
     b = ["sdf", 5, 9, "c"]
-    ops = diff(a, b)
+    ops, rops = diff(a, b)
 
     assert ops == [
         {"op": "replace", "path": Pointer([0]), "value": "sdf"},
         {"op": "replace", "path": Pointer([3]), "value": "c"},
         {"op": "remove", "path": Pointer([4])},
     ]
+    assert rops == [
+        {"op": "add", "path": Pointer(["-"]), "value": "fff"},
+        {"op": "replace", "path": Pointer([4]), "value": "sdfsdf"},
+        {"op": "replace", "path": Pointer([1]), "value": 1},
+    ]
 
 
 def test_list_end():
     a = [1, 2, 3]
     b = [1, 2, 3, 4]
-    ops = diff(a, b)
+    ops, rops = diff(a, b)
 
     assert ops == [
         {"op": "add", "path": Pointer(["-"]), "value": 4},
     ]
+    assert rops == [{"op": "remove", "path": Pointer([3])}]
 
 
 def test_dicts():
@@ -30,22 +36,30 @@ def test_dicts():
         "b": 6,
     }
     b = {"a": 3, "b": 6, "c": 7}
-    ops = diff(a, b)
+    ops, rops = diff(a, b)
 
     assert ops == [
-        {"op": "add", "path": Pointer(["c"]), "key": "c", "value": 7},
+        {"op": "add", "path": Pointer(["c"]), "value": 7},
         {"op": "replace", "path": Pointer(["a"]), "value": 3},
     ]
+    assert rops == [
+        {"op": "replace", "path": Pointer(["a"]), "value": 5},
+        {"op": "remove", "path": Pointer(["c"])},
+    ]
 
 
 def test_sets():
     a = {"a", "b"}
     b = {"a", "c"}
-    ops = diff(a, b)
+    ops, rops = diff(a, b)
 
     assert ops == [
-        {"op": "remove", "path": Pointer(["b"]), "value": "b"},
-        {"op": "add", "path": Pointer(["c"]), "value": "c"},
+        {"op": "remove", "path": Pointer(["b"])},
+        {"op": "add", "path": Pointer(["-"]), "value": "c"},
+    ]
+    assert rops == [
+        {"op": "remove", "path": Pointer(["c"])},
+        {"op": "add", "path": Pointer(["-"]), "value": "b"},
     ]
 
 
@@ -55,10 +69,15 @@ def test_mixed():
         "b": 6,
     }
     b = {"a": [5, 2, 9, {"b", "c"}], "b": 6, "c": 7}
-    ops = diff(a, b)
+    ops, rops = diff(a, b)
 
     assert ops == [
-        {"op": "add", "path": Pointer(["c"]), "key": "c", "value": 7},
+        {"op": "add", "path": Pointer(["c"]), "value": 7},
         {"op": "replace", "path": Pointer(["a", 1]), "value": 2},
-        {"op": "remove", "path": Pointer(["a", 3, "a"]), "value": "a"},
+        {"op": "remove", "path": Pointer(["a", 3, "a"])},
+    ]
+    assert rops == [
+        {"op": "add", "path": Pointer(["a", 3, "-"]), "value": "a"},
+        {"op": "replace", "path": Pointer(["a", 1]), "value": 7},
+        {"op": "remove", "path": Pointer(["c"])},
     ]

tests/test_pointer.py

@@ -3,10 +3,10 @@
 
 def test_pointer_get():
     obj = [1, 5, {"foo": 1, "bar": [1, 2, 3]}, "sdfsdf", "fff"]
-    assert Pointer(["1"]).evaluate(obj)[2] == 5
-    assert Pointer(["2", "bar", "1"]).evaluate(obj)[2] == 2
+    assert Pointer([1]).evaluate(obj)[2] == 5
+    assert Pointer([2, "bar", 1]).evaluate(obj)[2] == 2
 
 
 def test_pointer_str():
-    assert str(Pointer(["1"])) == "/1"
+    assert str(Pointer([1])) == "/1"
     assert str(Pointer(["foo", "bar", "-"])) == "/foo/bar/-"