Changeset 515 for elixir/trunk/elixir/collection.py

Timestamp:

11/12/09 14:47:53 (3 years ago)

Author:

ged

Message:

- Added a new collection which can resolve entities relative to the current

entity, for example "..other_module.Class" (based on patches from Johannes
Janssen, closes #93).

- Added a new entity option "resolve_root", which allows one to specify the

root module where your entities are defined. The string will be prepended
to all "absolute" entity paths. It can also be used on a per-entity basis.
This feature is based on a patch from Johannes Janssen, see #93.

Files:

• elixir/trunk/elixir/collection.py (modified) (5 diffs)

elixir/trunk/elixir/collection.py

@@ -3 +3 @@
 '''
 import sys
+import re
 
-# default entity collection
-class EntityCollection(list):
+class BaseCollection(list):
     def __init__(self, entities=None):
-        # _entities is a dict of entities keyed on their name.
-        self._entities = {}
         list.__init__(self)
         if entities is not None:
@@ -16 +14 @@
         for e in entities:
             self.append(e)
+
+    def clear(self):
+        del self[:]
+
+    def resolve_absolute(self, key, full_path, entity=None, root=None):
+        if root is None:
+            root = entity._descriptor.resolve_root
+        if root:
+            full_path = '%s.%s' % (root, full_path)
+        module_path, classname = full_path.rsplit('.', 1)
+        module = sys.modules[module_path]
+        res = getattr(module, classname, None)
+        if res is None:
+            if entity is not None:
+                raise Exception("Couldn't resolve target '%s' <%s> in '%s'!"
+                                % (key, full_path, entity.__name__))
+            else:
+                raise Exception("Couldn't resolve target '%s' <%s>!"
+                                % (key, full_path))
+        return res
+
+    def __getattr__(self, key):
+        return self.resolve(key)
+
+# default entity collection
+class GlobalEntityCollection(BaseCollection):
+    def __init__(self, entities=None):
+        # _entities is a dict of entities keyed on their name.
+        self._entities = {}
+        super(GlobalEntityCollection, self).__init__(entities)
 
     def append(self, entity):
@@ -31 +59 @@
         "source" entity when resolving relationship targets.
         '''
-        path = key.rsplit('.', 1)
-        classname = path.pop()
-        if path:
-            # Do we have a fully qualified entity name?
-            module = sys.modules[path.pop()]
-            return getattr(module, classname, None)
+        # Do we have a fully qualified entity name?
+        if '.' in key:
+            return self.resolve_absolute(key, key, entity)
         else:
             # Otherwise we look in the entities of this collection
@@ -42 +67 @@
             if res is None:
                 if entity:
-                    raise Exception("Couldn't resolve target '%s' in '%s'" \
+                    raise Exception("Couldn't resolve target '%s' in '%s'"
                                     % (key, entity.__name__))
                 else:
@@ -57 +82 @@
     def clear(self):
         self._entities = {}
-        del self[:]
+        super(GlobalEntityCollection, self).clear()
+
+# backward compatible name
+EntityCollection = GlobalEntityCollection
+
+_leading_dots = re.compile('^([.]*).*$')
+
+class RelativeEntityCollection(BaseCollection):
+    # the entity=None does not make any sense with a relative entity collection
+    def resolve(self, key, entity):
+        '''
+        Resolve a key to an Entity. The optional `entity` argument is the
+        "source" entity when resolving relationship targets.
+        '''
+        full_path = key
+
+        if '.' not in key or key.startswith('.'):
+            # relative target
+
+            # any leading dot is stripped and with each dot removed,
+            # the entity_module is stripped of one more chunk (starting with
+            # the last one).
+            num_dots = _leading_dots.match(full_path).end(1)
+            full_path = full_path[num_dots:]
+            chunks = entity.__module__.split('.')
+            chunkstokeep = len(chunks) - num_dots
+            if chunkstokeep < 0:
+                raise Exception("Couldn't resolve relative target "
+                    "'%s' relative to '%s'" % (key, entity.__module__))
+            entity_module = '.'.join(chunks[:chunkstokeep])
+
+            if entity_module and entity_module is not '__main__':
+                full_path = '%s.%s' % (entity_module, full_path)
+
+            root = ''
+        else:
+            root = None
+        return self.resolve_absolute(key, full_path, entity, root=root)
 
     def __getattr__(self, key):
-        return self.resolve(key)
+        raise NotImplementedError
 
-