Add option to generate test operations in diff

bin/jsondiff

@@ -18,6 +18,8 @@ parser.add_argument('-u', '--preserve-unicode', action='store_true',
                     help='Output Unicode character as-is without using Code Point')
 parser.add_argument('-v', '--version', action='version',
                     version='%(prog)s ' + jsonpatch.__version__)
+parser.add_argument('-t', '--test-ops', action='store_true',
+                    help='Generate before-state test ops for remove/replace')
 
 
 def main():
@@ -32,7 +34,7 @@ def diff_files():
     args = parser.parse_args()
     doc1 = json.load(args.FILE1)
     doc2 = json.load(args.FILE2)
-    patch = jsonpatch.make_patch(doc1, doc2)
+    patch = jsonpatch.make_patch(doc1, doc2, generate_test_ops=args.test_ops)
     if patch.patch:
         print(json.dumps(patch.patch, indent=args.indent, ensure_ascii=not(args.preserve_unicode)))
         sys.exit(1)

jsonpatch.py

@@ -157,7 +157,7 @@ def apply_patch(doc, patch, in_place=False, pointer_cls=JsonPointer):
     return patch.apply(doc, in_place)
 
 
-def make_patch(src, dst, pointer_cls=JsonPointer):
+def make_patch(src, dst, generate_test_ops=False, pointer_cls=JsonPointer):
     """Generates patch by comparing two document objects. Actually is
     a proxy to :meth:`JsonPatch.from_diff` method.
 
@@ -170,6 +170,12 @@ def make_patch(src, dst, pointer_cls=JsonPointer):
     :param pointer_cls: JSON pointer class to use.
     :type pointer_cls: Type[JsonPointer]
 
+    :param generate_test_ops: While :const:`True` generate test operations
+                              capturing previous values of `replace`/`remove`
+                              operations. By default do not generate these
+                              operations.
+    :type generate_test_ops: bool
+
     >>> src = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
     >>> dst = {'baz': 'qux', 'numbers': [1, 4, 7]}
     >>> patch = make_patch(src, dst)
@@ -178,7 +184,7 @@ def make_patch(src, dst, pointer_cls=JsonPointer):
     True
     """
 
-    return JsonPatch.from_diff(src, dst, pointer_cls=pointer_cls)
+    return JsonPatch.from_diff(src, dst, generate_test_ops=generate_test_ops, pointer_cls=pointer_cls)
 
 
 class PatchOperation(object):
@@ -475,6 +481,11 @@ def apply(self, obj):
 
         return obj
 
+    def _on_undo_add(self, path, key):
+        return key
+
+    def _on_undo_remove(self, path, key):
+        return key
 
 class CopyOperation(PatchOperation):
     """ Copies an object property or an array element to a new location """
@@ -628,7 +639,7 @@ def from_string(cls, patch_str, loads=None, pointer_cls=JsonPointer):
 
     @classmethod
     def from_diff(
-            cls, src, dst, optimization=True, dumps=None,
+            cls, src, dst, generate_test_ops=False, dumps=None,
             pointer_cls=JsonPointer,
     ):
         """Creates JsonPatch instance based on comparison of two document
@@ -641,6 +652,12 @@ def from_diff(
         :param dst: Data source document object.
         :type dst: dict
 
+        :param generate_test_ops: While :const:`True` generate test operations
+                                  capturing previous values of `replace`/`remove`
+                                  operations. By default do not generate these
+                                  operations.
+        :type generate_test_ops: bool
+
         :param dumps: A function of one argument that produces a serialized
                       JSON string.
         :type dumps: function
@@ -658,7 +675,7 @@ def from_diff(
         True
         """
         json_dumper = dumps or cls.json_dumper
-        builder = DiffBuilder(src, dst, json_dumper, pointer_cls=pointer_cls)
+        builder = DiffBuilder(src, dst, json_dumper, generate_test_ops=generate_test_ops, pointer_cls=pointer_cls)
         builder._compare_values('', None, src, dst)
         ops = list(builder.execute())
         return cls(ops, pointer_cls=pointer_cls)
@@ -711,9 +728,10 @@ def _get_operation(self, operation):
 
 class DiffBuilder(object):
 
-    def __init__(self, src_doc, dst_doc, dumps=json.dumps, pointer_cls=JsonPointer):
+    def __init__(self, src_doc, dst_doc, dumps=json.dumps, generate_test_ops=False, pointer_cls=JsonPointer):
         self.dumps = dumps
         self.pointer_cls = pointer_cls
+        self.generate_test_ops = generate_test_ops
         self.index_storage = [{}, {}]
         self.index_storage2 = [[], []]
         self.__root = root = []
@@ -801,6 +819,11 @@ def _item_added(self, path, key, item):
                 for v in self.iter_from(index):
                     op.key = v._on_undo_remove(op.path, op.key)
 
+            if self.generate_test_ops:
+                prev_op_index = index[0]
+                if isinstance(prev_op_index[2], TestOperation):
+                    self.remove(prev_op_index)
+
             self.remove(index)
             if op.location != _path_join(path, key):
                 new_op = MoveOperation({
@@ -819,6 +842,13 @@ def _item_added(self, path, key, item):
             self.store_index(item, new_index, _ST_ADD)
 
     def _item_removed(self, path, key, item):
+        if self.generate_test_ops:
+            test_index = self.insert(TestOperation({
+                'op': 'test',
+                'path': _path_join(path, key),
+                'value': item,
+            }, pointer_cls=self.pointer_cls))
+
         new_op = RemoveOperation({
             'op': 'remove',
             'path': _path_join(path, key),
@@ -844,14 +874,25 @@ def _item_removed(self, path, key, item):
                     'path': op.location,
                 }, pointer_cls=self.pointer_cls)
                 new_index[2] = new_op
+                if self.generate_test_ops:
+                    self.remove(test_index)
 
             else:
                 self.remove(new_index)
+                if self.generate_test_ops:
+                    self.remove(test_index)
 
         else:
             self.store_index(item, new_index, _ST_REMOVE)
 
-    def _item_replaced(self, path, key, item):
+    def _item_replaced(self, path, key, item, old_item):
+        if self.generate_test_ops:
+            self.insert(TestOperation({
+                'op': 'test',
+                'path': _path_join(path, key),
+                'value': old_item,
+            }, pointer_cls=self.pointer_cls))
+
         self.insert(ReplaceOperation({
             'op': 'replace',
             'path': _path_join(path, key),
@@ -921,7 +962,7 @@ def _compare_values(self, path, key, src, dst):
             return
 
         else:
-            self._item_replaced(path, key, dst)
+            self._item_replaced(path, key, dst, src)
 
 
 def _path_join(path, key):