add basic diffing

Author: Korijn

.gitignore

@@ -1 +1,2 @@
 *.pyc
+.vscode

patchdiff/__init__.py

@@ -1,8 +1,67 @@
-from typing import Dict, List, Set, Tuple, Union
+from typing import Dict, List
 
 
 __version__ = "0.1.0"
 
 
-def diff(a: Union[Dict, List, Set, Tuple], b: Union[Dict, List, Set, Tuple]):
-    pass
+def diff_lists(input: List, output: List):
+    memory = {(0, 0): {"ops": [], "cost": 0}}
+
+    def dist(i, j):
+        if (i, j) not in memory:
+            if i > 0 and j > 0 and not diff(input[i - 1], output[j - 1]):
+                step = dist(i - 1, j - 1)
+            else:
+                paths = []
+                if i > 0:
+                    base = dist(i - 1, j)
+                    op = {"op": "remove", "idx": i - 1}
+                    paths.append({
+                        "ops": base["ops"] + [op],
+                        "cost": base["cost"] + 1,
+                    })
+                if j > 0:
+                    base = dist(i, j - 1)
+                    op = {"op": "add", "idx": j - 1, "value": output[j - 1]}
+                    paths.append({
+                        "ops": base["ops"] + [op],
+                        "cost": base["cost"] + 1,
+                    })
+                if i > 0 and j > 0:
+                    base = dist(i - 1, j - 1)
+                    op = {"op": "replace", "idx": i - 1, "original": input[i - 1], "value": output[j - 1]}
+                    paths.append({
+                        "ops": base["ops"] + [op],
+                        "cost": base["cost"] + 1,
+                    })
+                step = min(paths, key=lambda a: a["cost"])
+            memory[(i, j)] = step
+        return memory[(i, j)]
+
+    return dist(len(input), len(output))["ops"]
+
+
+def diff_dicts(input: Dict, output: Dict):
+    ops = []
+    input_keys = set(input.keys())
+    output_keys = set(output.keys())
+    for key in input_keys - output_keys:
+        ops.append({"op": "remove", "key": key})
+    for key in output_keys - input_keys:
+        ops.append({"op": "add", "key": key, "value": output[key]})
+    for key in input_keys & output_keys:
+        ops.extend(diff(input[key], output[key]))
+    return ops
+
+
+def diff(input, output):
+    # TODO: track paths
+    # TODO: properly check equality
+    if input == output:
+        return []
+    if isinstance(input, list) and isinstance(output, list):
+        return diff_lists(input, output)
+    if isinstance(input, dict) and isinstance(output, dict):
+        return diff_dicts(input, output)
+    # TODO: sets, tuples
+    return [{"op": "replace", "value": output}]

tests/test_all.py

@@ -1,7 +1,29 @@
 from patchdiff import diff
 
 
-def test_all():
-    a = [1, 5, 9, "sdfsdf"]
-    b = ["sdf", "c"]
-    assert diff(a, b)
+def test_list():
+    a = [1, 5, 9, "sdfsdf", "fff"]
+    b = ["sdf", 5, 9, "c"]
+    ops = diff(a, b)
+
+    assert len(ops) == 3
+    assert (ops[0]["op"], ops[0]["idx"]) == ("replace", 0)
+    assert (ops[1]["op"], ops[1]["idx"]) == ("replace", 3)
+    assert (ops[2]["op"], ops[2]["idx"]) == ("remove", 4)
+
+
+def test_dicts():
+    a = {
+        "a": 5,
+        "b": 6,
+    }
+    b = {
+        "a": 3,
+        "b": 6,
+        "c": 7
+    }
+    ops = diff(a, b)
+
+    assert len(ops) == 2
+    assert (ops[0]["op"], ops[0]["key"]) == ("add", "c")
+    assert (ops[1]["op"], ops[1]["value"]) == ("replace", 3)