Changeset 511

Timestamp:

11/09/09 13:02:22 (3 years ago)

Author:

ged

Message:

- Entities can now be declared "abstract" so that they do not create a table,

etc... This allows, among others, an entity to inherit from multiple abstract
classes (patch from Stéphane Klein, closes #89).

Location:

elixir/trunk

Files:

• CHANGES (modified) (1 diff)
• elixir/entity.py (modified) (5 diffs)
• elixir/options.py (modified) (3 diffs)
• tests/test_abstract.py (added)

elixir/trunk/CHANGES

@@ -2 +2 @@
 
 New features:
+- Entities can now be declared "abstract" so that they do not create a table,
+  etc... This allows, among others, an entity to inherit from multiple abstract
+  classes (patch from Stéphane Klein, closes #89).
 
 Changes:

elixir/trunk/elixir/entity.py

@@ -19 +19 @@
 
 import elixir
-from elixir.statements import process_mutators
+from elixir.statements import process_mutators, MUTATORS
 from elixir import options
 from elixir.properties import Property
@@ -65 +65 @@
         for base in entity.__bases__:
             if isinstance(base, EntityMeta):
-                if is_entity(base):
+                if (
+                    is_entity(base) and
+                    (not is_abstract_entity(base))
+                ):
                     if self.parent:
                         raise Exception(
@@ -693 +696 @@
     return base_props
 
+def is_abstract_entity(dict_or_cls):
+    if isinstance(dict_or_cls, dict):
+        mutators = dict_or_cls.get(MUTATORS, [])
+    else:
+        mutators = getattr(dict_or_cls, MUTATORS, [])
+        
+    for m in mutators:
+        if 'abstract' in m[2]:
+            return m[2]['abstract']
+
+    return False
 
 def instrument_class(cls):
@@ -706 +720 @@
 
     # Determine whether this entity is a *direct* subclass of its base entity
-    entity_base = None
+    entity_bases = []
     for base in cls.__bases__:
         if isinstance(base, EntityMeta):
-            if not is_entity(base):
-                entity_base = base
-
-    if entity_base:
+            if not is_entity(base) or is_abstract_entity(base):
+                entity_bases.append(base)
+ 
+    base_props = []
+    if entity_bases:
         # If so, copy the base entity properties ('Property' instances).
         # We use inspect.getmembers (instead of __dict__) so that we also
         # get the properties from the parents of the base_class if any.
-        base_props = getmembers(entity_base,
-                                lambda a: isinstance(a, Property))
-        base_props = [(name, deepcopy(attr)) for name, attr in base_props]
-    else:
-        base_props = []
+        for base in entity_bases:
+            base_props += [(name, deepcopy(attr)) for name, attr in 
+                           getmembers(base, lambda a: isinstance(a, Property))]
 
     # Process attributes (using the assignment syntax), looking for
@@ -750 +763 @@
         # be registered in an entity collection, nor to have a table name and
         # so on.
+
+        if is_abstract_entity(dict_):
+            return
+
         if not is_entity(cls):
             if isinstance(cls, EntityMeta):

elixir/trunk/elixir/options.py

@@ -35 +35 @@
 |                     | #mapping-class-inheritance-hierarchies for an         |
 |                     | explanation of the different kinds of inheritances.   |
++---------------------+-------------------------------------------------------+
+| ``abstract``        | Set 'abstract'=True to declare abstract entity.       |
+|                     | Abstract base classes are useful when you want to put |
+|                     | some common information into a number of other        |
+|                     | entities. Abstract entity will not be used to create  |
+|                     | any database table. Instead, when it is used as a base|
+|                     | class for other entity, its fields will be added to   |
+|                     | those of the child class.                             |
 +---------------------+-------------------------------------------------------+
 | ``polymorphic``     | Whether the inheritance should be polymorphic or not. |
@@ -165 +173 @@
 using_options_defaults (nor specifically on a particular Entity) will use the
 global defaults, so you don't have to provide a default value for all options,
-but only those you want to change.
-
+but only those you want to change. Please also note that this statement does
+not work on normal entities, and the normal using_options statement does not
+work on base classes (because normal options do not and should not propagate to
+the children classes).
 '''
 
@@ -205 +215 @@
 #
 options_defaults = dict(
+    abstract=False,
     inheritance='single',
     polymorphic=True,