Changeset 299

Timestamp:

01/31/08 16:45:34 (10 months ago)

Author:

johnbywater

Message:

Refactored temporal properties, added temporal property object and register classes.

Files:

• trunk/src/dm/db.py (modified) (4 diffs)
• trunk/src/dm/dom/base.py (modified) (1 diff)
• trunk/src/dm/dom/meta.py (modified) (3 diffs)
• trunk/src/dm/dom/registry.py (modified) (3 diffs)
• trunk/src/dm/dom/temporaltest.py (modified) (6 diffs)
• trunk/src/dm/testunit.py (modified) (1 diff)
• trunk/src/dm/timepoint.py (modified) (1 diff)
• trunk/src/dm/timepointtest.py (modified) (2 diffs)

trunk/src/dm/db.py

@@ -495 +495 @@
-        for a in self.attributes:
-            if a.dom.isTemporal:
+                # We don't persist temporal attributes on the parent.
-                continue
-            mapperClassAttribute = a.createMapperClassAttribute()
@@ -756 +757 @@
-                    mapperValue = self.parent.domainObject
-                    self.domainObject.parent = mapperValue
-
-
-
-
+#
+#
+#
+#
-                    continue
-
+
+
-                r = metaAttr.dom.createTemporalCollection(self.domainObject)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-                if mostRecent:
-                    mappedValue = mostRecent.recordedValue
-                else:
-                    #print "LOAD: No record, creating initial value..."
-                    mappedValue = metaAttr.dom.createInitialValue(
-                        self.domainObject
-                    )
-                #print "LOAD: Temporal '%s' value: %s" % (metaAttr.dom.name, mappedValue)
-            elif metaAttr.isDomainObjectRef:
-                mapper = getattr(self, dbName)
@@ -838 +806 @@
-        isChanged = False
-        for metaAttr in self.meta.attributes:
-
-
+
+
+
+
-                r = metaAttr.dom.createTemporalCollection(self.domainObject)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-            elif metaAttr.isDomainObjectRef:
-getattr(self.domainObject, metaAttr.domName)
+domValue
-                if domainObject and hasattr(domainObject, 'record'):
-                    domRecord = domainObject.record
@@ -929 +826 @@
-                    isChanged = True
-            else:
-                domValue = getattr(self.domainObject, metaAttr.domName)
-                dbValue = getattr(self, metaAttr.dbName)
-                if domValue != dbValue:

trunk/src/dm/dom/base.py

@@ -556 +556 @@
-        return reprAttrs
-
-
-    def getSortOnValue(self):
-        if self.sortOnName:

trunk/src/dm/dom/meta.py

@@ -96 +96 @@
-        classAttrs = {
-            'meta': self,
-            'isUnique': self.isUnique,
-            'isCached': self.isCached,
-        }
-        return self.createClass(className, baseClass, classAttrs)
@@ -176 +174 @@
-    def setTemporalDomainClass(self, domainClass):
-        self.temporalDomainClass = domainClass
-        self.temporalDomainClass.registerKeyName = 'id'
-        self.temporalDomainClass.isUnique = False
-        self.temporalDomainClass.isCached = True
-        if self.isBitemporalActual:
-            self.temporalDomainClass.sortOnName = 'dateCreated'
-        else:
-            self.temporalDomainClass.sortOnName = 'id'
-        self.temporalDomainClass.sortAscending = False
-
-    def createTemporalCollection(self, domainObject):
-        if not domainObject:
-            raise Exception, "Need a domain object! %s" % domainObject
-
-
-
+
+
+
+
+
-        return register
-        
@@ -259 +251 @@
-    def duplicateTemporal(self):
-        attrMeta = self.duplicateSelf()
-        # Not bitemporal ATM. Just an idea for 'stepping down' the temporal: 
-        if self.isBitemporal:
-             attrMeta.isTemporal = True
-             attrMeta.isBitemporal = False
-             attrMeta.isBitemporalActual = True
+             attrMeta.isTemporal = True
-        else:
-             attrMeta.isTemporal = False

trunk/src/dm/dom/registry.py

@@ -2 +2 @@
-from dm.dom.base import *
-from dm.dom.stateful import *
+from dm.dom.temporal import TemporalProperty, BitemporalProperty, BitemporalActual
-from dm.ioc import * 
-from dm.exceptions import * 
@@ -15 +16 @@
-        self.domainClassRegister = None
-        self.backgroundObjectCache = []
-
-    def registerCoreDomainClasses(self):
-        pass
-         
-    def loadBackgroundObjects(self):
-        "Creates and caches refs to all background domain objects."
-        pass
-        
-    def retrieveItem(self, key):
-        return getattr(self, key)
-
-    def createDomainClass(self, metaDomainObject):
-        baseClass = DomainObject
-        domainClass = metaDomainObject.createDomainClass(baseClass)
-        self.registerDomainClass(domainClass)
-        return domainClass
-
-    def getDomainClassRegister(self):
-        if not self.domainClassRegister:
-            self.domainClassRegister = DomainClassRegister()
-        return self.domainClassRegister
-
-    def isDomainClassRegistered(self, className):
-        if className.__class__.__name__ != 'str':
-            message = 'className is not a str: %s' % str(className)
-            raise Exception, message
-        classRegister = self.getDomainClassRegister()
-        return className in classRegister
-    
-    def getDomainClass(self, className):
-        classRegister = self.getDomainClassRegister()
-        if not className in classRegister:
-            raise Exception, "Domain class '%s' is not defined." % className
-        return classRegister[className]
-
-    def registerDomainClass(self, domainClass):
@@ -85 +52 @@
-            self.checkHasAsForHasManys(classRegister[name])
-        temporalAttrs = []
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    def setMetaAttributesFromClass(self, domainClass, domainClassMeta):

trunk/src/dm/dom/temporaltest.py

@@ -7 +7 @@
-import mx.DateTime
-from time import sleep
-
-
+, BitemporalActual
+, BitemporalActualCollection
-
-def suite():
@@ -14 +14 @@
-        unittest.makeSuite(TestTemporal),  # Example
-        unittest.makeSuite(TestTemporalProperty),
+        unittest.makeSuite(TestBitemporalActual),
-        unittest.makeSuite(TestBitemporalProperty),
-    ]
@@ -34 +35 @@
-class TestTemporalProperty(TestCase):
-
+    timepoint = RequiredFeature('Timepoint')
+
-    def setUp(self):
-        super(TestTemporalProperty, self).setUp()
-
+
+
-
-    def tearDown(self):
+        self.timepoint.reset()
-        self.collection = None
+        if self.property:
+            self.property.delete()
-
-    def test_collection(self):
-        self.failUnlessEqual(type(self.collection), TemporalCollection)
+        self.failUnlessEqual(self.collection.ownerName, 'parent')
+        self.failUnlessEqual(self.collection.isCached, True)
+        self.failUnlessEqual(self.collection.getDomainClass(), TemporalProperty)
+        self.failUnlessEqual(TemporalProperty.isUnique, False)
+        self.failUnlessEqual(TemporalProperty.isConstant, True)
+        self.failUnlessEqual(TemporalProperty.registerKeyName, 'id')
+        self.failUnlessEqual(TemporalProperty.sortOnName, 'id')
+        self.failUnlessEqual(TemporalProperty.sortAscending, False)
+
+    def test_instance(self):
+        self.property = self.collection.create(recordedValue='')
+        self.failUnless(self.property.dateCreated)
+        self.failUnlessEqual(self.property.getSortOnValue(), self.property.id)
+
+    def test_getReferenceTime(self):
+        time1 = mx.DateTime.DateTime(2003, 6, 1)
+        self.timepoint.recorded = time1
+        self.failUnlessEqual(self.collection.getReferenceTime(), time1)
+
+
+class TestBitemporalActual(TestCase):
+
+    timepoint = RequiredFeature('Timepoint')
+
+    def setUp(self):
+        super(TestBitemporalActual, self).setUp()
+        self.collection = BitemporalActual.createRegister(ownerName='parent')
+        self.property = None
+
+    def tearDown(self):
+        self.timepoint.reset()
+        self.collection = None
+        if self.property:
+            self.property.delete()
+
+    def test_collection(self):
+        self.failUnlessEqual(type(self.collection), BitemporalActualCollection)
+        self.failUnlessEqual(self.collection.ownerName, 'parent')
+        self.failUnlessEqual(self.collection.isCached, True)
+        self.failUnlessEqual(self.collection.getDomainClass(), BitemporalActual)
+        self.failUnlessEqual(BitemporalActual.isUnique, False)
+        self.failUnlessEqual(BitemporalActual.isConstant, True)
+        self.failUnlessEqual(BitemporalActual.registerKeyName, 'id')
+        self.failUnlessEqual(BitemporalActual.sortOnName, 'dateCreated')
+        self.failUnlessEqual(BitemporalActual.sortAscending, False)
+
+    def test_instance(self):
+        time1 = mx.DateTime.DateTime(2003, 6, 1)
+        time2 = mx.DateTime.DateTime(2003, 7, 1)
+        time3 = mx.DateTime.DateTime(2003, 8, 1)
+        time4 = mx.DateTime.DateTime(2003, 8, 1)
+        property1 = self.collection.create(dateCreated=time1, recordedValue="1")
+        property2 = self.collection.create(dateCreated=time3, recordedValue="2")
+        property3 = self.collection.create(dateCreated=time2, recordedValue="3")
+        property4 = None
+        try:
+            self.failUnless(property1.dateCreated)
+            self.failUnlessEqual(property1.getSortOnValue(), (property1.dateCreated, property1.id))
+            sortedList = self.collection.findDomainObjects()
+            self.failUnlessEqual(sortedList, [property2, property3, property1])
+            self.failUnlessEqual(sortedList[0].dateCreated, time3)
+            self.failUnlessEqual(sortedList[1].dateCreated, time2)
+            self.failUnlessEqual(sortedList[2].dateCreated, time1)
+            self.failUnlessEqual(sortedList[0].recordedValue, "2")
+            property4 = self.collection.create(dateCreated=time3, recordedValue="4")
+            sortedList = self.collection.findDomainObjects()
+            self.failUnlessEqual(sortedList[0].dateCreated, time3)
+            self.failUnlessEqual(sortedList[0].recordedValue, "4", sortedList)
+        finally:
+            if property4:
+                property4.delete()
+            property3.delete()
+            property2.delete()
+            property1.delete()
+
+    def test_getReferenceTime(self):
+        time1 = mx.DateTime.DateTime(2003, 6, 1)
+        self.timepoint.actual = time1
+        self.failUnlessEqual(self.collection.getReferenceTime(), time1)
-        
-
+
+
-class TestBitemporalProperty(TestCase):
+
+    timepoint = RequiredFeature('Timepoint')
-
-    def setUp(self):
-        super(TestBitemporalProperty, self).setUp()
-
+ownerName='parent'
-
-    def tearDown(self):
+        self.timepoint.reset()
-        self.collection = None
-
-    def test_collection(self):
-        self.failUnlessEqual(type(self.collection), BitemporalCollection)
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -159 +317 @@
-        temporal.haircolor = haircolor2
-        temporal.save()
-        print "Sleeping now!"
-        import time
-        time.sleep(5)
-        #  - check present is most recent
-        self.timepoint.reset()
@@ -209 +364 @@
-        self.timepoint.reset()
-        temporal = self.temporals[self.fixtureName]
-        print "Sleeping... %s" % temporal.haircolor
-        sleep(5)
-        self.failUnlessEqual(temporal.haircolor, haircolor3)
-        self.timepoint.actual = yearsAgo
@@ -221 +374 @@
-        self.timepoint.actual = yearsAgo
-        temporal = self.temporals[self.fixtureName]
-
+My Natural Color
-        self.timepoint.reset()
-        self.timepoint.recorded = revisionTime

trunk/src/dm/testunit.py

@@ -28 +28 @@
-        self.registry.registerDomainClass(Temporal)
-        self.registry.temporals = Temporal.createRegister()
+        from dm.dom.temporal import TemporalProperty, BitemporalProperty, BitemporalActual
+        self.registry.registerDomainClass(TemporalProperty)
+        self.registry.registerDomainClass(BitemporalProperty)
+        self.registry.registerDomainClass(BitemporalActual)
-
-

trunk/src/dm/timepoint.py

@@ -38 +38 @@
-        return mx.DateTime.now()
-
+    def isActualPresent(self):
+        return (self._actual == None)
+

trunk/src/dm/timepointtest.py

@@ -19 +19 @@
-
-    def tearDown(self):
+        self.timepoint.reset()
-        self.timepoint = None
-
@@ -45 +46 @@
-        self.failUnless(now2 > now1)
-
+    def test_isActualNow(self):
+        self.timepoint.reset()
+        self.failUnless(self.timepoint.isActualPresent())
+        self.timepoint.actual = self.lastweek
+        self.failIf(self.timepoint.isActualPresent())
+        self.timepoint.reset()
+        self.failUnless(self.timepoint.isActualPresent())
+        
-
-
+
+