Changeset 597:db9ac6dc904f

Timestamp:

18/05/12 20:56:52 (12 months ago)

Author:

Santiago Piccinini (SAn) <piccinini.santiago@…>

Branch:

multisite

Message:

DynamicSettings? now support all methods of its value

Location:

cyclope

Files:

• core/multisite/threadlocals.py (modified) (2 diffs)
• default_multisite_settings.py (modified) (1 diff)
• tests.py (modified) (3 diffs)

cyclope/core/multisite/threadlocals.py

@@ -23 +23 @@
 # http://github.com/shestera/django-multisite
 
+import inspect
 from threading import local
 
 _thread_locals = local()
 
+_dont_override = set(['__repr__', '__getattribute__', '__new__',
+                      '__init__', '__setitem__'])
+
+class _None(object):
+    pass
+
 class DynamicSetting(object):
-    def __init__(self, setting_name, *args):
-        # the name of the setting whose value we will hold in _thread_locals
+    def __init__(self, setting_name, value_or_type):
+        value, type_ = _None, None
+        if isinstance(value_or_type, type):
+            type_ = value_or_type
+        else:
+            type_ = type(value_or_type)
+            value = value_or_type
+
+        self.__class__ = type('DS%s' % repr(type_), (self.__class__, object), {})
+
         self.setting_name = setting_name
-        if len(args) > 1:
-            raise TypeError("DynamicSetting only supports one value")
-        elif len(args) == 1:
-            self.set(args[0])
+        if value is not _None:
+            self.set(value)
+
+        methods = set()
+        for name, attr in type_.__dict__.iteritems():
+            if inspect.ismethod(attr) or inspect.ismethoddescriptor(attr):
+                methods.add(name)
+        methods_to_override = methods - _dont_override
+
+        def method(self, *args, **kwargs):
+            return getattr(self.get_value(), name)
+
+        for name in methods_to_override:
+            def method(self, *args, **kwargs):
+                print name, args, kwargs
+                return type_.__dict__[name](*args, **kwargs)
+
+            def outer(name, *args, **kwargs):
+                def inner(self, *args, **kwargs):
+                    return getattr(self.get_value(), name)(*args, **kwargs)
+                return inner
+            setattr(self.__class__, name, outer(name))
 
     def set(self, value):
@@ -54 +87 @@
         return getattr(_thread_locals, self.setting_name, None)
 
-    def __getitem__(self, attr):
-        return self.get_value().__getitem__(attr)
-
-    def __setitem__(self, attr, value):
-        raise NotImplemented
-
-    def __getattribute__(self, attr):
-        if attr == 'setting_name':
-            return super(DynamicSetting, self).__getattribute__(attr)
-
-        current = getattr(_thread_locals, self.setting_name, None)
-        if hasattr(current, attr):
-            return getattr(current, attr)
-        else:
-            return super(DynamicSetting, self).__getattribute__(attr)
-
-    def __unicode__(self):
-        return unicode(self.get_value())
-
-    def __str__(self):
-        return str(self.get_value())
-
-    def __repr__(self):
-        return "<DynamicSetting: %s>" % repr(self.get_value())
-
-    def __float__(self):
-        return float(self.get_value())
-
     def __nonzero__(self):
         return bool(self.get_value())
 
+    def __setitem__(self, attr, value):
+        raise NotImplementedError
 
+    def __repr__(self):
+        val = self.get_value()
+        return "<DynamicSetting: %s>" % repr(val)
 
 class RequestHostHook(object):

cyclope/default_multisite_settings.py

@@ -42 +42 @@
 
 
-CYCLOPE_PAGINATION = DynamicSetting('CYCLOPE_PAGINATION')
+CYCLOPE_PAGINATION = DynamicSetting('CYCLOPE_PAGINATION', dict)

cyclope/tests.py

@@ -629 +629 @@
 
 class DynamicSettingTestCase(TestCase):
-    def setUp(self):
-        self.ds = DynamicSetting("SETTING")
 
     def test_api(self):
-        ds = DynamicSetting("SETTING_A")
         ds = DynamicSetting("SETTING_A", 1)
         self.assertEqual(int(ds), 1)
@@ -639 +636 @@
     def test_int(self):
         integer = 3
-        self.ds.set(integer)
-        self.assertEqual(int(self.ds), integer)
-        self.assertEqual(str(self.ds), str(integer))
+        ds = DynamicSetting("SETTING", integer)
+        self.assertEqual(int(ds), integer)
+        self.assertEqual(str(ds), str(integer))
+        self.assertEqual(ds * 5, integer * 5)
+        self.assertEqual(5 * ds, integer * 5)
+        self.assertEqual(float(ds), float(integer))
+        self.assertEqual(ds/2, integer/2)
 
     def test_str(self):
-        self.ds.set("foo")
-        self.assertEqual(str(self.ds), "foo")
+        ds = DynamicSetting("SETTING", "foo")
+        self.assertEqual(str(ds), "foo")
+        self.assertEqual(ds + "bar", "foobar")
 
     def test_dict(self):
         d = {"foo": "bar"}
-        self.ds.set(d)
-        self.assertEqual(str(self.ds["foo"]), "bar")
+        ds = DynamicSetting("SETTING", d)
+
+        self.assertEqual(str(ds["foo"]), "bar")
 
         # Test override the entire dict
-        local_cache =  self.ds["foo"]
+        local_cache =  ds["foo"]
         self.assertEqual(str(local_cache), "bar")
 
-        self.ds.set({"foo": "baz"})
+        ds.set({"foo": "baz"})
         self.assertEqual(str(local_cache), "baz")
 
     def test_tuple(self):
-        self.ds.set(("a", "b"))
-        self.assertEqual(str(self.ds[0]), "a")
-        self.assertEqual(str(self.ds[1]), "b")
-
-        self.ds.set(("c", "d"))
-        self.assertEqual(str(self.ds[0]), "c")
-        self.assertEqual(str(self.ds[1]), "d")
-
-        self.ds.set(("a", "b"))
-        local_cache = self.ds[0]
-        self.ds.set(("c", "d"))
+        ds = DynamicSetting("SETTING", ("a", "b"))
+        self.assertEqual(str(ds[0]), "a")
+        self.assertEqual(str(ds[1]), "b")
+
+        ds.set(("c", "d"))
+        self.assertEqual(str(ds[0]), "c")
+        self.assertEqual(str(ds[1]), "d")
+
+        ds.set(("a", "b"))
+        local_cache = ds[0]
+        ds.set(("c", "d"))
         self.assertEqual(str(local_cache), "c")
 
         # slice
-        self.ds.set(("a", "b", "c"))
-        self.assertEqual(str(self.ds[:2][0]), "a")
+        ds.set(("a", "b", "c"))
+        self.assertEqual(str(ds[:2][0]), "a")
 
     def test_recursive_tuple(self):
-        self.ds.set((("foo",), ("bar", )))
-        first_elem = self.ds[0]
+        ds = DynamicSetting("SETTING", (("foo",), ("bar", )))
+        first_elem = ds[0]
         self.assertEqual(str(first_elem[0]), "foo")
 
@@ -686 +689 @@
 
     def test_bool(self):
-        self.ds.set(True)
-        self.assertTrue(bool(self.ds) is True)
-
-        self.ds.set(False)
-        self.assertTrue(bool(self.ds) is False)
+        ds = DynamicSetting("SETTING", True)
+        self.assertTrue(bool(ds) is True)
+
+        ds.set(False)
+        self.assertTrue(bool(ds) is False)
 
     def test_repr(self):
         d = 5
-        self.ds.set(d)
-        self.assertEqual(repr(self.ds), "<DynamicSetting: %s>" % repr(d))
+        ds = DynamicSetting("SETTING", d)
+        self.assertEqual(repr(ds), "<DynamicSetting: %s>" % repr(d))
 
     def test_float(self):
-        self.ds.set(1.0)
-        self.assertEqual(float(self.ds), 1.0)
+        ds = DynamicSetting("SETTING", 1.0)
+        self.assertEqual(float(ds), 1.0)
 
     def test_none(self):
-        self.ds.set(None)
+        ds = DynamicSetting("SETTING", None)
         self.assertTrue()