Make it possible for from_diff to support custom types (issue #107)

Author: clj

jsonpatch.py

@@ -258,7 +258,7 @@ def from_string(cls, patch_str):
         return cls(patch)
 
     @classmethod
-    def from_diff(cls, src, dst, optimization=True):
+    def from_diff(cls, src, dst, optimization=True, dumps=json.dumps):
         """Creates JsonPatch instance based on comparing of two document
         objects. Json patch would be created for `src` argument against `dst`
         one.
@@ -269,6 +269,10 @@ def from_diff(cls, src, dst, optimization=True):
         :param dst: Data source document object.
         :type dst: dict
 
+        :param dumps: A function of one argument that produces a serialized
+                      JSON string.
+        :type dumps: function
+
         :return: :class:`JsonPatch` instance.
 
         >>> src = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
@@ -279,7 +283,7 @@ def from_diff(cls, src, dst, optimization=True):
         True
         """
 
-        builder = DiffBuilder()
+        builder = DiffBuilder(dumps)
         builder._compare_values('', None, src, dst)
         ops = list(builder.execute())
         return cls(ops)
@@ -637,7 +641,8 @@ def apply(self, obj):
 
 class DiffBuilder(object):
 
-    def __init__(self):
+    def __init__(self, dumps):
+        self.dumps = dumps
         self.index_storage = [{}, {}]
         self.index_storage2 = [[], []]
         self.__root = root = []
@@ -832,7 +837,7 @@ def _compare_values(self, path, key, src, dst):
         # and ignore those that don't. The performance of this could be
         # improved by doing more direct type checks, but we'd need to be
         # careful to accept type changes that don't matter when JSONified.
-        elif json.dumps(src) == json.dumps(dst):
+        elif self.dumps(src) == self.dumps(dst):
             return
 
         else:

tests.py

@@ -4,6 +4,7 @@
 from __future__ import unicode_literals
 
 import json
+import decimal
 import doctest
 import unittest
 import jsonpatch
@@ -445,6 +446,20 @@ def test_issue103(self):
         self.assertEqual(res, dst)
         self.assertIsInstance(res['A'], float)
 
+    def test_custom_types(self):
+        def default(obj):
+            if isinstance(obj, decimal.Decimal):
+                return str(obj)
+            raise TypeError('Unknown type')
+
+        def dumps(obj):
+            return json.dumps(obj, default=default)
+
+        old = {'value': decimal.Decimal('1.0')}
+        new = {'value': decimal.Decimal('1.00')}
+        patch = jsonpatch.JsonPatch.from_diff(old, new, dumps=dumps)
+        new_from_patch = jsonpatch.apply_patch(old, patch)
+        self.assertEqual(new, new_from_patch)
 
 
 class OptimizationTests(unittest.TestCase):