Pyrseas WC

diff --git a/pyrseas/dbobject/__init__.py b/pyrseas/dbobject/__init__.py
index f6f8191..2017d55 100644
--- a/pyrseas/dbobject/__init__.py
+++ b/pyrseas/dbobject/__init__.py
@@ -121,8 +121,7 @@ def ownable(func):
     @wraps(func)
     def add_alter(obj, *args, **kwargs):
         stmts = func(obj, *args, **kwargs)
-        if hasattr(obj, 'owner'):
-            stmts.append(obj.alter_owner())
+        stmts.append(obj.alter_owner())
         return stmts
     return add_alter

@@ -149,7 +148,7 @@ class DbObject(object):

     allprivs = ''

-    def __init__(self, **attrs):
+    def __init__(self, owner=None, privileges=None, **attrs):
         """Initialize the catalog object from a dictionary of attributes

         :param attrs: the dictionary of attributes
@@ -160,6 +159,11 @@ class DbObject(object):
         """
         self.depends_on = []

+        self.owner = owner
+        if isinstance(privileges, basestring):
+            privileges = privileges.split(',')
+        self.privileges = privileges or []
+
         for key, val in list(attrs.items()):
             if val or key in self.keylist:
                 if key in ['definition', 'description', 'source'] and \
@@ -301,32 +305,37 @@ class DbObject(object):
         :param no_privs: exclude privilege information
         :return: dictionary
         """
-        dct = self.__dict__.copy()
-        for key in self.keylist:
-            del dct[key]
-        if no_owner and hasattr(self, 'owner'):
-            del dct['owner']
-        if hasattr(self, 'privileges'):
-            if no_privs:
-                del dct['privileges']
-            else:
-                dct['privileges'] = self.map_privs()
+        rv = {}
+        for k, v in self.__dict__.iteritems():
+            # Don't dump any private attribute
+            if k.startswith('_'):
+                continue

-        # Never dump the oid
-        dct.pop('oid', None)
+            # Never dump the oid
+            if k == 'oid':
+                continue

-        # Only dump dependencies that can't be inferred from the context
-        deps = set(dct.pop('depends_on', ()))
-        deps -= self.get_implied_deps(db)
-        if deps:
-            dct['depends_on'] = sorted([ dep.extern_key() for dep in deps ])
+            # Don't dump the keylist items
+            if k in self.keylist:
+                continue

-        # Don't drop any private attribute
-        for k in dct.keys():
-            if k.startswith('_'):
-                del dct[k]
+            if k == 'owner' and no_owner:
+                continue
+
+            if k == 'privileges':
+                if no_privs:
+                    continue
+                else:
+                    v = self.map_privs()
+
+            if k == 'depends_on':
+                v = set(v)
+                v -= self.get_implied_deps(db)
+                v = sorted(dep.extern_key() for dep in v)
+
+            rv[k] = v

-        return dct
+        return rv

     def to_map(self, db, no_owner=False, no_privs=False):
         """Convert an object to a YAML-suitable format
@@ -349,9 +358,8 @@ class DbObject(object):
         :return: list
         """
         privlist = []
-        owner = self.owner if hasattr(self, 'owner') else ''
         for prv in self.privileges:
-            privlist.append(privileges_to_map(prv, self.allprivs, owner))
+            privlist.append(privileges_to_map(prv, self.allprivs, self.owner))
         return privlist

     def _comment_text(self):
@@ -400,9 +408,8 @@ class DbObject(object):

     def alter_sql(self, inobj, no_owner=False):
         stmts = []
-        if not no_owner and hasattr(inobj, 'owner') and hasattr(self, 'owner'):
-            if inobj.owner != self.owner:
-                stmts.append(self.alter_owner(inobj.owner))
+        if not no_owner and inobj.owner != self.owner:
+            stmts.append(self.alter_owner(inobj.owner))
         stmts.append(self.diff_privileges(inobj))
         stmts.append(self.diff_description(inobj))
         return stmts
@@ -417,9 +424,8 @@ class DbObject(object):
         :return: list of SQL statements
         """
         stmts = []
-        currprivs = self.privileges if hasattr(self, 'privileges') else {}
-        newprivs = inobj.privileges if hasattr(inobj, 'privileges') else {}
-        stmts.append(diff_privs(self, currprivs, inobj, newprivs))
+        stmts.append(diff_privs(self, self.privileges,
+                                inobj, inobj.privileges))
         return stmts

     def diff_description(self, inobj):
@@ -558,11 +564,8 @@ class DbObjectDict(dict):
         This is may be overriden by derived classes as needed.
         """
         for obj in self.fetch():
-            if hasattr(obj, 'privileges'):
-                obj.privileges = obj.privileges.split(',')
             self[obj.key()] = obj
-            if hasattr(obj, 'oid'):
-                self.by_oid[obj.oid] = obj
+            self.by_oid[obj.oid] = obj

     def to_map(self, db, opts):
         """Convert the object dictionary to a regular dictionary
diff --git a/pyrseas/dbobject/column.py b/pyrseas/dbobject/column.py
index 49aceb8..bf36ba4 100644
--- a/pyrseas/dbobject/column.py
+++ b/pyrseas/dbobject/column.py
@@ -69,9 +69,8 @@ class Column(DbSchemaObject):
         :return: list of SQL statements
         """
         stmts = []
-        currprivs = self.privileges if hasattr(self, 'privileges') else {}
-        newprivs = incol.privileges if hasattr(incol, 'privileges') else {}
-        stmts.append(diff_privs(self._table, currprivs, incol._table, newprivs,
+        stmts.append(diff_privs(self._table, self.privileges,
+                                incol._table, incol.privileges,
                                 self.name))
         return stmts

diff --git a/pyrseas/dbobject/foreign.py b/pyrseas/dbobject/foreign.py
index 04eef12..8d25876 100644
--- a/pyrseas/dbobject/foreign.py
+++ b/pyrseas/dbobject/foreign.py
@@ -127,9 +127,8 @@ class ForeignDataWrapper(DbObjectWithOptions):
         :return: list of SQL statements
         """
         stmts = super(ForeignDataWrapper, self).diff_map(inwrapper)
-        if hasattr(inwrapper, 'owner'):
-            if inwrapper.owner != self.owner:
-                stmts.append(self.alter_owner(inwrapper.owner))
+        if inwrapper.owner != self.owner:
+            stmts.append(self.alter_owner(inwrapper.owner))
         stmts.append(self.diff_description(inwrapper))
         return stmts