# Source code for sqlobject.versioning

    from datetime import datetime
    from sqlobject import col, events, SQLObject, AND

    class Version(SQLObject):

        def restore(self):
            values = self.sqlmeta.asDict()
            del values['id']
            del values['masterID']
            del values['dateArchived']
            for _col in self.extraCols:
                del values[_col]
            self.masterClass.get(self.masterID).set(**values)

        def nextVersion(self):
            version = self.select(
                AND(self.q.masterID == self.masterID, self.q.id > self.id),
                orderBy=self.q.id)
            if version.count():
                return version[0]
            else:
                return self.master

        def getChangedFields(self):
            next = self.nextVersion()
            columns = self.masterClass.sqlmeta.columns
            fields = []
            for column in columns:
                if column not in ["dateArchived", "id", "masterID"]:
                    if getattr(self, column) != getattr(next, column):
                        fields.append(column.title())

            return fields

        @classmethod
        def select(cls, clause=None, *args, **kw):
            if not getattr(cls, '_connection', None):
                cls._connection = cls.masterClass._connection
            return super(Version, cls).select(clause, *args, **kw)

        def __getattr__(self, attr):
            if attr in self.__dict__:
                return self.__dict__[attr]
            else:
                return getattr(self.master, attr)

    def getColumns(columns, cls):
        for column, defi in cls.sqlmeta.columnDefinitions.items():
            if column.endswith("ID") and isinstance(defi, col.ForeignKey):
                column = column[:-2]

            # remove incompatible constraints
            kwds = dict(defi._kw)
            for kw in ["alternateID", "unique"]:
                if kw in kwds:
                    del kwds[kw]
            columns[column] = defi.__class__(**kwds)

        # ascend heirarchy
        if cls.sqlmeta.parentClass:
            getColumns(columns, cls.sqlmeta.parentClass)

    class Versioning(object):
        def __init__(self, extraCols=None):
            if extraCols:
                self.extraCols = extraCols
            else:
                self.extraCols = {}
            pass

        def __addtoclass__(self, soClass, name):
            self.name = name
            self.soClass = soClass

            attrs = {'dateArchived': col.DateTimeCol(default=datetime.now),
                     'master': col.ForeignKey(self.soClass.__name__),
                     'masterClass': self.soClass,
                     'extraCols': self.extraCols
                     }

            getColumns(attrs, self.soClass)

            attrs.update(self.extraCols)

            self.versionClass = type(self.soClass.__name__ + 'Versions',
                                     (Version,),
                                     attrs)

            if '_connection' in self.soClass.__dict__:
                self.versionClass._connection = \
                    self.soClass.__dict__['_connection']

            events.listen(self.createTable,
                          soClass, events.CreateTableSignal)
            events.listen(self.rowUpdate, soClass,
                          events.RowUpdateSignal)

        def createVersionTable(self, cls, conn):
            self.versionClass.createTable(ifNotExists=True, connection=conn)

        def createTable(self, soClass, connection, extra_sql, post_funcs):
            assert soClass is self.soClass
            post_funcs.append(self.createVersionTable)

        def rowUpdate(self, instance, kwargs):
            if instance.childName and instance.childName != self.soClass.__name__:
                return  # if you want your child class versioned, version it

            values = instance.sqlmeta.asDict()
            del values['id']
            values['masterID'] = instance.id
            self.versionClass(connection=instance._connection, **values)

        def __get__(self, obj, type=None):
            if obj is None:
                return self
            return self.versionClass.select(
                self.versionClass.q.masterID == obj.id, connection=obj._connection)