Merge lp:~jkakar/storm/json-property into lp:storm

[Jamu Kakar]

This branch introduces the following changes:

- Most of the logic in the PickleVariable code has been split out into
  a new EncodedValueVariable class.

- A new JSONVariable, based on EncodedValueVariable, is available.

- A new JSON property is available.

[Stuart Bishop (stub)]

This all looks good.

There is a lot of cut-and-paste code in test_properties that should be shared, but that isn't an issue you need to deal with on this branch.

review: Approve

[Jamu Kakar (jkakar)]

Stuart:

Thanks for the review! I thought about fixing the cut-and-paste issue
in the property tests, but it would be a bit messy, so I decided to
avoid it for now.

[Thomas Herve (therve)]

[1] The json module is only available in 2.6, we should at least keep 2.5 compatibility for now. I suggest moving the import at the class level (so that it's only used when a person use the variable), and fallback on simplejson for 2.5. The tests should be skipped if json/simplejson is not available.

review: Needs Fixing

[lp:~jkakar/storm/json-property]

389. By Jamu Kakar on 2011-09-07

- Merged Gavin's improvements.

[Thomas Herve (therve)]

Looks good, +1!

review: Approve

=== added file 'storm/compat.py'
--- storm/compat.py	1970-01-01 00:00:00 +0000
+++ storm/compat.py	2011-09-07 14:15:40 +0000
@@ -0,0 +1,32 @@
+#
+# Copyright (c) 2011 Canonical
+#
+# Written by Gustavo Niemeyer <[e-mail]>
+#
+# This file is part of Storm Object Relational Mapper.
+#
+# Storm is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# Storm is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+__all__ = [
+    "json",
+    ]
+
+try:
+    import json
+except ImportError:
+    try:
+        import simplejson as json
+    except ImportError:
+        json = None

=== modified file 'storm/locals.py'
--- storm/locals.py	2011-02-14 12:17:54 +0000
+++ storm/locals.py	2011-09-07 14:15:40 +0000
@@ -18,9 +18,9 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
-from storm.properties import Bool, Int, Float, RawStr, Chars, Unicode, Pickle
+from storm.properties import Bool, Int, Float, RawStr, Chars, Unicode
 from storm.properties import List, Decimal, DateTime, Date, Time, Enum, UUID
-from storm.properties import TimeDelta
+from storm.properties import TimeDelta, Pickle, JSON
 from storm.references import Reference, ReferenceSet, Proxy
 from storm.database import create_database
 from storm.exceptions import StormError

=== modified file 'storm/properties.py'
--- storm/properties.py	2009-02-04 06:33:24 +0000
+++ storm/properties.py	2011-09-07 14:15:40 +0000
@@ -29,14 +29,14 @@
     Variable, VariableFactory, BoolVariable, IntVariable, FloatVariable,
     DecimalVariable, RawStrVariable, UnicodeVariable, DateTimeVariable,
     DateVariable, TimeVariable, TimeDeltaVariable, UUIDVariable,
-    PickleVariable, ListVariable, EnumVariable)
+    PickleVariable, JSONVariable, ListVariable, EnumVariable)
 
 
 
 __all__ = ["Property", "SimpleProperty",
            "Bool", "Int", "Float", "Decimal", "RawStr", "Unicode",
            "DateTime", "Date", "Time", "TimeDelta", "UUID", "Enum",
-           "Pickle", "List", "PropertyRegistry"]
+           "Pickle", "JSON", "List", "PropertyRegistry"]
 
 
 class Property(object):
@@ -172,6 +172,9 @@
 class Pickle(SimpleProperty):
     variable_class = PickleVariable
 
+class JSON(SimpleProperty):
+    variable_class = JSONVariable
+
 
 class List(SimpleProperty):
     variable_class = ListVariable

=== modified file 'storm/variables.py'
--- storm/variables.py	2011-02-14 12:17:54 +0000
+++ storm/variables.py	2011-09-07 14:15:40 +0000
@@ -27,6 +27,7 @@
 except ImportError:
     uuid = None
 
+from storm.compat import json
 from storm.exceptions import NoneError
 from storm import Undef, has_cextensions
 
@@ -48,6 +49,7 @@
     "EnumVariable",
     "UUIDVariable",
     "PickleVariable",
+    "JSONVariable",
     "ListVariable",
 ]
 
@@ -566,7 +568,7 @@
         if (self._checkpoint_state is not Undef and
             self.get_state() != self._checkpoint_state):
             self.event.emit("changed", self, None, self._value, False)
-    
+
     def _detect_changes_and_stop(self, obj_info):
         self._detect_changes(obj_info)
         if self._event_system is not None:
@@ -586,29 +588,55 @@
         super(MutableValueVariable, self).set(value, from_db)
 
 
-class PickleVariable(MutableValueVariable):
+class EncodedValueVariable(MutableValueVariable):
+
     __slots__ = ()
 
     def parse_set(self, value, from_db):
         if from_db:
             if isinstance(value, buffer):
                 value = str(value)
-            return pickle.loads(value)
+            return self._loads(value)
         else:
             return value
 
     def parse_get(self, value, to_db):
         if to_db:
-            return pickle.dumps(value, -1)
+            return self._dumps(value)
         else:
             return value
 
     def get_state(self):
-        return (self._lazy_value, pickle.dumps(self._value, -1))
+        return (self._lazy_value, self._dumps(self._value))
 
     def set_state(self, state):
         self._lazy_value = state[0]
-        self._value = pickle.loads(state[1])
+        self._value = self._loads(state[1])
+
+
+class PickleVariable(EncodedValueVariable):
+
+    def _loads(self, value):
+        return pickle.loads(value)
+
+    def _dumps(self, value):
+        return pickle.dumps(value, -1)
+
+
+class JSONVariable(EncodedValueVariable):
+
+    __slots__ = ()
+
+    def __init__(self, *args, **kwargs):
+        assert json is not None, (
+            "Neither the json nor the simplejson module was found.")
+        super(JSONVariable, self).__init__(*args, **kwargs)
+
+    def _loads(self, value):
+        return json.loads(value)
+
+    def _dumps(self, value):
+        return json.dumps(value)
 
 
 class ListVariable(MutableValueVariable):

=== modified file 'tests/properties.py'
--- tests/properties.py	2009-02-04 06:33:24 +0000
+++ tests/properties.py	2011-09-07 14:15:40 +0000
@@ -26,6 +26,7 @@
 except ImportError:
     uuid = None
 
+from storm.compat import json
 from storm.exceptions import NoneError, PropertyPathError
 from storm.properties import PropertyPublisherMeta
 from storm.properties import *
@@ -693,6 +694,67 @@
         del self.obj
         self.assertEquals(changes, [(self.variable1, None, ["a"], False)])
 
+    def test_json(self):
+        # Skip test if json support is not available.
+        if json is None:
+            return
+
+        self.setup(JSON, default_factory=dict, allow_none=False)
+
+        self.assertTrue(isinstance(self.column1, Column))
+        self.assertTrue(isinstance(self.column2, Column))
+        self.assertEquals(self.column1.name, "column1")
+        self.assertEquals(self.column1.table, self.SubClass)
+        self.assertEquals(self.column2.name, "prop2")
+        self.assertEquals(self.column2.table, self.SubClass)
+        self.assertTrue(isinstance(self.variable1, JSONVariable))
+        self.assertTrue(isinstance(self.variable2, JSONVariable))
+
+        self.assertEquals(self.obj.prop1, {})
+        self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
+        self.obj.prop2 = None
+        self.assertEquals(self.obj.prop2, None)
+
+        self.obj.prop1 = []
+        self.assertEquals(self.obj.prop1, [])
+        self.obj.prop1.append("a")
+        self.assertEquals(self.obj.prop1, ["a"])
+
+    def test_json_events(self):
+        # Skip test if json support is not available.
+        if json is None:
+            return
+
+        self.setup(JSON, default_factory=list, allow_none=False)
+
+        changes = []
+        def changed(owner, variable, old_value, new_value, fromdb):
+            changes.append((variable, old_value, new_value, fromdb))
+
+        # Can't checkpoint Undef.
+        self.obj.prop2 = []
+
+        self.obj_info.checkpoint()
+        self.obj_info.event.emit("start-tracking-changes", self.obj_info.event)
+        self.obj_info.event.hook("changed", changed)
+
+        self.assertEquals(self.obj.prop1, [])
+        self.assertEquals(changes, [])
+        self.obj.prop1.append("a")
+        self.assertEquals(changes, [])
+
+        # Check "flush" event. Notice that the other variable wasn't
+        # listed, since it wasn't changed.
+        self.obj_info.event.emit("flush")
+        self.assertEquals(changes, [(self.variable1, None, ["a"], False)])
+
+        del changes[:]
+
+        # Check "object-deleted" event. Notice that the other variable
+        # wasn't listed again, since it wasn't changed.
+        del self.obj
+        self.assertEquals(changes, [(self.variable1, None, ["a"], False)])
+
     def test_list(self):
         self.setup(List, default_factory=list, allow_none=False)
 

=== modified file 'tests/variables.py'
--- tests/variables.py	2011-01-19 00:32:48 +0000
+++ tests/variables.py	2011-09-07 14:15:40 +0000
@@ -28,6 +28,7 @@
 except ImportError:
     uuid = None
 
+from storm.compat import json
 from storm.exceptions import NoneError
 from storm.variables import *
 from storm.event import EventSystem
@@ -825,13 +826,16 @@
         self.assertEquals(variable.get(), value)
 
 
-class PickleVariableTest(TestHelper):
+class EncodedValueVariableTestMixin(object):
+
+    encoding = None
+    variable_type = None
 
     def test_get_set(self):
         d = {"a": 1}
-        d_dump = pickle.dumps(d, -1)
+        d_dump = self.encoding.dumps(d, -1)
 
-        variable = PickleVariable()
+        variable = self.variable_type()
 
         variable.set(d)
         self.assertEquals(variable.get(), d)
@@ -853,7 +857,7 @@
     def test_pickle_events(self):
         event = EventSystem(marker)
 
-        variable = PickleVariable(event=event, value_factory=list)
+        variable = self.variable_type(event=event, value_factory=list)
 
         changes = []
         def changed(owner, variable, old_value, new_value, fromdb):
@@ -887,6 +891,21 @@
         self.assertEquals(changes, [(variable, None, ["a"], False)])
 
 
+class PickleVariableTest(EncodedValueVariableTestMixin, TestHelper):
+
+    encoding = pickle
+    variable_type = PickleVariable
+
+
+class JSONVariableTest(EncodedValueVariableTestMixin, TestHelper):
+
+    encoding = json
+    variable_type = JSONVariable
+
+    def is_supported(self):
+        return json is not None
+
+
 class ListVariableTest(TestHelper):
 
     def test_get_set(self):