Changeset 303

Timestamp:

02/07/08 15:57:55 (5 years ago)

Author:

ged

Message:

• Added an alternate (nicer) syntax to define synonym properties. This syntax
  has a more limited scope, except that it can refer to properties defined in
  a parent entity. This is based on a patch from Alexandre da Silva.
  

Location:

elixir/trunk

Files:

• CHANGES (modified) (1 diff)
• elixir/__init__.py (modified) (3 diffs)
• elixir/fields.py (modified) (1 diff)
• elixir/properties.py (modified) (4 diffs)
• tests/test_properties.py (modified) (1 diff)

elixir/trunk/CHANGES

@@ -7 +7 @@
 - Added support for custom base classes which inherit from another class (ie
   not directly from object).
+- Added an alternate (nicer) syntax to define synonym properties.  This syntax
+  has a more limited scope, except that it can refer to properties defined in 
+  a parent entity. This is based on a patch from Alexandre da Silva.
 
 Changes:

elixir/trunk/elixir/__init__.py

@@ -32 +32 @@
                                  has_and_belongs_to_many, \
                                  ManyToOne, OneToOne, OneToMany, ManyToMany
-from elixir.properties import has_property, GenericProperty, ColumnProperty
+from elixir.properties import has_property, GenericProperty, ColumnProperty, \
+                              Synonym
 from elixir.statements import Statement
 
@@ -39 +40 @@
 
 __all__ = ['Entity', 'EntityMeta',
-           'Field', 'has_field', 'with_fields',
-           'has_property', 'GenericProperty', 'ColumnProperty',
+           'Field', 'has_field', 'with_fields', 
+           'has_property', 'GenericProperty', 'ColumnProperty', 'Synonym',
            'belongs_to', 'has_one', 'has_many', 'has_and_belongs_to_many',
            'ManyToOne', 'OneToOne', 'OneToMany', 'ManyToMany',
@@ -46 +47 @@
            'options_defaults', 'metadata', 'objectstore', 'session',
            'create_all', 'drop_all',
-           'setup_all', 'cleanup_all', 
+           'setup_all', 'cleanup_all',
            'setup_entities', 'cleanup_entities'] + \
            sqlalchemy.types.__all__

elixir/trunk/elixir/fields.py

@@ -67 +67 @@
 | ``synonym``       | Specify a synonym name for this field. The field will   |
 |                   | also be usable under that name in keyword-based Query   |
-|                   | functions such as filter_by.                            |
+|                   | functions such as filter_by. The Synonym class (see the |
+|                   | `properties` module) provides a similar functionality   |
+|                   | with an (arguably) nicer syntax, but a limited scope.   |
 +-------------------+---------------------------------------------------------+
 

elixir/trunk/elixir/properties.py

@@ -4 +4 @@
 properties such as fields and relationships (for those, please consult the 
 corresponding modules), but also provides some more specialized properties, 
-such as `ColumnProperty`. It also provides the GenericProperty class which 
-allows you to wrap any SQLAlchemy property, and its DSL-syntax equivalent: 
-has_property_.
+such as `ColumnProperty` and `Synonym`. It also provides the GenericProperty 
+class which allows you to wrap any SQLAlchemy property, and its DSL-syntax 
+equivalent: has_property_.
 
 `has_property`
@@ -32 +32 @@
 
 from elixir.statements import PropertyStatement
-from sqlalchemy.orm import column_property
+from sqlalchemy.orm import column_property, synonym
 
 __doc_all__ = ['EntityBuilder', 'Property', 'GenericProperty', 
@@ -150 +150 @@
     def evaluate_property(self, prop):
         return prop
+
 
 class ColumnProperty(GenericProperty):
@@ -179 +180 @@
         return column_property(prop.label(self.name))
 
+
+class Synonym(GenericProperty):
+    '''
+    This class represents a synonym property of another property (column, ...)
+    of an entity.  As opposed to the `synonym` kwarg to the Field class (which 
+    share the same goal), this class can be used to define a synonym of a 
+    property defined in a parent class (of the current class). On the other
+    hand, it cannot define a synonym for the purpose of using a standard python 
+    property in queries. See the Field class for details on that usage.
+
+    .. sourcecode:: python
+
+    class Person(Entity):
+        name = Field(String(30))
+        primary_email = Field(String(100))
+        email_address = Synonym('primary_email')
+
+    class User(Person):
+        user_name = Synonym('name')
+        password = Field(String(20))
+    '''
+
+    def evaluate_property(self, prop):
+        return synonym(prop)
+
 #class Composite(GenericProperty):
 #    def __init__(self, prop):

elixir/trunk/tests/test_properties.py

@@ -162 +162 @@
         assert p.name == 'Mr. X'
 
+    def test_synonym_class(self):
+        class Person(Entity):
+            name = Field(String(30))
+            primary_email = Field(String(100))
+            email_address = Synonym('primary_email')
+
+        class User(Person):
+            user_name = Synonym('name')
+            password = Field(String(20))
+
+        setup_all(True)
+
+        alexandre = Person(
+            name = u'Alexandre da Silva',
+            email_address = u'x@y.com'
+        )
+        johann = User(
+            name = 'Johann Felipe Voigt',
+            email_address = 'y@z.com',
+            password = 'unencrypted'
+        )
+
+        session.flush(); session.clear()
+
+        p = Person.get_by(name='Alexandre da Silva')
+        assert p.primary_email == 'x@y.com'
+
+        u = User.get_by(user_name='Johann Felipe Voigt')
+        assert u.email_address == 'y@z.com'
+
+        u.email_address = 'new@z.com'
+        session.flush(); session.clear()
+
+        p = Person.get_by(name='Johann Felipe Voigt')
+        assert p.primary_email == 'new@z.com'
+