Added laziness option

Author: derek-schaefer

README.rst

@@ -65,6 +65,7 @@ Add a ``JSONField`` to your model like any other field.
 
  - ``default``: Falls back on ``"null"`` if not provided and ``null=False``, otherwise ``None``
  - ``db_type``: Allows you to specify the column type (default: ``text``)
+ - ``lazy``: Defer deserialization until the field is directly accessed (default: ``True``)
  - ``encoder``: Custom JSON encoder (default: ``DjangoJSONEncoder``)
  - ``decoder``: Custom JSON decoder (default: ``json_field.fields.JSONDecoder``)
  - ``encoder_kwargs``: Specify all arguments to the encoder (overrides ``encoder``)

json_field/fields.py

@@ -67,33 +67,35 @@ class Creator(object):
     Taken from django.db.models.fields.subclassing.
     """
 
-    _parent_key = '_json_field_cache'
+    _state_key = '_json_field_state'
 
-    def __init__(self, field):
+    def __init__(self, field, lazy):
         self.field = field
+        self.lazy = lazy
 
     def __get__(self, obj, type=None):
         if obj is None:
             raise AttributeError('Can only be accessed via an instance.')
 
-        cache = getattr(obj, self._parent_key, None)
-        if cache is None:
-            cache = {}
-            setattr(obj, self._parent_key, cache)
+        if self.lazy:
+            state = getattr(obj, self._state_key, None)
+            if state is None:
+                state = {}
+                setattr(obj, self._state_key, state)
 
-        key = '%s_deserialized' %  self.field.name
+            if state.get(self.field.name, False):
+                return obj.__dict__[self.field.name]
 
-        if cache.get(key, False):
-            return obj.__dict__[self.field.name]
-
-        value = self.field.to_python(obj.__dict__[self.field.name])
-        obj.__dict__[self.field.name] = value
-        cache[key] = True
+            value = self.field.to_python(obj.__dict__[self.field.name])
+            obj.__dict__[self.field.name] = value
+            state[self.field.name] = True
+        else:
+            value = obj.__dict__[self.field.name]
 
         return value
 
     def __set__(self, obj, value):
-        obj.__dict__[self.field.name] = value # deserialized when accessed
+        obj.__dict__[self.field.name] = value if self.lazy else self.field.to_python(value)
 
 class JSONField(models.TextField):
     """ Stores and loads valid JSON objects. """
@@ -107,6 +109,7 @@ def __init__(self, *args, **kwargs):
         self._db_type = kwargs.pop('db_type', None)
         self.evaluate_formfield = kwargs.pop('evaluate_formfield', False)
 
+        self.lazy = kwargs.pop('lazy', True)
         encoder = kwargs.pop('encoder', DjangoJSONEncoder)
         decoder = kwargs.pop('decoder', JSONDecoder)
         encoder_kwargs = kwargs.pop('encoder_kwargs', {})
@@ -170,7 +173,7 @@ def set_json(model_instance, value):
             return setattr(model_instance, self.attname, self.to_python(value))
         setattr(cls, 'set_%s_json' % self.name, set_json)
 
-        setattr(cls, name, Creator(self)) # deferred deserialization
+        setattr(cls, name, Creator(self, lazy=self.lazy)) # deferred deserialization
 
 try:
     # add support for South migrations

test_project/app/models.py

@@ -5,4 +5,5 @@
 class Test(models.Model):
 
     json = JSONField()
+    json_eager = JSONField(lazy=False)
     json_null = JSONField(blank=True, null=True, evaluate_formfield=True)

test_project/app/tests.py

@@ -33,6 +33,26 @@ def test_simple(self):
         t8.json = {'asdf':123}
         self.assertEqual({'asdf':123}, t8.json)
 
+    def test_eager(self):
+        t1 = Test.objects.create(json_eager=123)
+        self.assertEqual(123, Test.objects.get(pk=t1.pk).json_eager)
+        t2 = Test.objects.create(json_eager='123')
+        self.assertEqual(123, Test.objects.get(pk=t2.pk).json_eager)
+        t3 = Test.objects.create(json_eager=[123])
+        self.assertEqual([123], Test.objects.get(pk=t3.pk).json_eager)
+        t4 = Test.objects.create(json_eager='[123]')
+        self.assertEqual([123], Test.objects.get(pk=t4.pk).json_eager)
+        t5 = Test.objects.create(json_eager={'test':[1,2,3]})
+        self.assertEqual({'test':[1,2,3]}, Test.objects.get(pk=t5.pk).json_eager)
+        t6 = Test.objects.create(json_eager='{"test":[1,2,3]}')
+        self.assertEqual({'test':[1,2,3]}, Test.objects.get(pk=t6.pk).json_eager)
+        t7 = Test.objects.create(json_eager=[1,2,3])
+        t7.json_eager = {'asdf':123}
+        self.assertEqual({'asdf':123}, t7.json_eager)
+        t8 = Test.objects.get(pk=t7.pk)
+        t8.json_eager = {'asdf':123}
+        self.assertEqual({'asdf':123}, t8.json_eager)
+
     def test_null(self):
         t1 = Test.objects.create(json=None)
         self.assertEqual(None, t1.json)