Merge lp:~jkakar/storm/reference-set-order-by into lp:storm

[Jamu Kakar]

This branch makes it possible to use a string, to work around
circular dependency issues, when defining the order_by property of a
ReferenceSet.

[Gustavo Niemeyer (niemeyer)]

Nice, looks clear and good!

review: Approve

[Sidnei da Silva (sidnei)]

Looks great. +1!

review: Approve

=== modified file 'storm/references.py'
--- storm/references.py	2010-02-08 11:30:44 +0000
+++ storm/references.py	2010-06-01 08:52:24 +0000
@@ -214,6 +214,7 @@
     # not be available yet.
     _relation1 = LazyAttribute("_relation1", "_build_relations")
     _relation2 = LazyAttribute("_relation2", "_build_relations")
+    _order_by = LazyAttribute("_order_by", "_build_relations")
 
     def __init__(self, local_key1, remote_key1,
                  remote_key2=None, local_key2=None, order_by=None):
@@ -221,7 +222,7 @@
         self._remote_key1 = remote_key1
         self._remote_key2 = remote_key2
         self._local_key2 = local_key2
-        self._order_by = order_by
+        self._default_order_by = order_by
         self._cls = None
 
     def __get__(self, local, cls=None):
@@ -252,6 +253,11 @@
     def _build_relations(self):
         resolver = PropertyResolver(self, self._cls)
 
+        if self._default_order_by is not None:
+            self._order_by = resolver.resolve(self._default_order_by)
+        else:
+            self._order_by = None
+
         self._local_key1 = resolver.resolve(self._local_key1)
         self._remote_key1 = resolver.resolve(self._remote_key1)
         self._relation1 = Relation(self._local_key1, self._remote_key1,
@@ -913,7 +919,7 @@
     def _resolve_string(self, property_path):
         if self._registry is None:
             try:
-                registry = self._used_cls._storm_property_registry
+                self._registry = self._used_cls._storm_property_registry
             except AttributeError:
                 raise RuntimeError("When using strings on references, "
                                    "classes involved must be subclasses "
@@ -921,7 +927,7 @@
             cls = _find_descriptor_class(self._used_cls, self._reference)
             self._namespace = "%s.%s" % (cls.__module__, cls.__name__)
 
-        return registry.get(property_path, self._namespace)
+        return self._registry.get(property_path, self._namespace)
 
 
 def _find_descriptor_class(used_cls, descr):

=== modified file 'tests/store/base.py'
--- tests/store/base.py	2010-04-16 07:12:13 +0000
+++ tests/store/base.py	2010-06-01 08:52:24 +0000
@@ -33,13 +33,16 @@
     Asc, Desc, Select, LeftJoin, SQL, Count, Sum, Avg, And, Or, Eq, Lower)
 from storm.variables import Variable, UnicodeVariable, IntVariable
 from storm.info import get_obj_info, ClassAlias
-from storm.exceptions import *
+from storm.exceptions import (
+    ClosedError, ConnectionBlockedError, FeatureError, LostObjectError,
+    NoStoreError, NotFlushedError, NotOneError, OrderLoopError, UnorderedError,
+    WrongStoreError)
 from storm.cache import Cache
-from storm.store import *
+from storm.store import AutoReload, EmptyResultSet, Store
 from storm.store import ResultSet
 
 from tests.info import Wrapper
-from tests.helper import run_this, TestHelper
+from tests.helper import TestHelper
 
 
 class Foo(object):
@@ -4287,6 +4290,12 @@
         self.assertEquals(type(bar.foo), MyFoo)
 
     def test_string_indirect_reference_set(self):
+        """
+        A L{ReferenceSet} can have its reference keys specified as strings
+        when the class its a member of uses the L{PropertyPublisherMeta}
+        metaclass.  This makes it possible to work around problems with
+        circular dependencies by delaying property resolution.
+        """
         class Base(object):
             __metaclass__ = PropertyPublisherMeta
 
@@ -4320,6 +4329,39 @@
                           (200, "Title 200"),
                          ])
 
+    def test_string_reference_set_order_by(self):
+        """
+        A L{ReferenceSet} can have its default order by specified as a string
+        when the class its a member of uses the L{PropertyPublisherMeta}
+        metaclass.  This makes it possible to work around problems with
+        circular dependencies by delaying resolution of the order by column.
+        """
+        class Base(object):
+            __metaclass__ = PropertyPublisherMeta
+
+        class MyFoo(Base):
+            __storm_table__ = "foo"
+            id = Int(primary=True)
+            title = Unicode()
+            bars = ReferenceSet("id", "MyLink.foo_id",
+                                "MyLink.bar_id", "MyBar.id",
+                                order_by="MyBar.title")
+
+        class MyBar(Base):
+            __storm_table__ = "bar"
+            id = Int(primary=True)
+            title = Unicode()
+
+        class MyLink(Base):
+            __storm_table__ = "link"
+            __storm_primary__ = "foo_id", "bar_id"
+            foo_id = Int()
+            bar_id = Int()
+
+        foo = self.store.get(MyFoo, 20)
+        items = [(bar.id, bar.title) for bar in foo.bars]
+        self.assertEquals(items, [(200, "Title 200"), (100, "Title 300")])
+
     def test_flush_order(self):
         foo1 = Foo()
         foo2 = Foo()