Issue #25: Reviewers' suggestions.

Author: boonya

domain_models/views.py

@@ -7,40 +7,59 @@
 class ContextViewMetaClass(type):
     """Context view meta class."""
 
-    attributes = dict()
-
     def __new__(mcs, class_name, bases, attributes):
         """Context view class factory."""
-        mcs.attributes = attributes
-        mcs.validate(bases)
+        mcs.validate(bases, attributes)
         cls = type.__new__(mcs, class_name, bases, attributes)
-        cls.__fields__ = mcs.get_properties()
+        cls.__fields__ = mcs.get_properties(attributes)
         return cls
 
     @classmethod
-    def validate(mcs, bases):
+    def validate(mcs, bases, attributes):
         """Check attributes."""
         if bases[0] is object:
             return None
-        mcs.check_model_cls()
-        mcs.check_include_exclude()
 
-    @classmethod
-    def check_model_cls(mcs):
-        """Check __model_cls__ attribute."""
-        model_cls = mcs.attributes.get('__model_cls__')
+        mcs.check_model_cls(attributes)
+        mcs.check_include_exclude(attributes)
+        mcs.check_properties(attributes)
+        mcs.match_unknown_attrs(attributes)
+
+    @staticmethod
+    def check_model_cls(attributes):
+        """Check __model_cls__ attribute.
+
+        :type attributes: dict
+        """
+        model_cls = attributes.get('__model_cls__')
         if model_cls is None:
             raise AttributeError("Attribute __model_cls__ is required.")
 
         if not issubclass(model_cls, models.DomainModel):
             raise TypeError("Attribute __model_cls__ must be subclass of "
                             "DomainModel.")
 
-    @classmethod
-    def check_include_exclude(mcs):
-        """Check __include__ and __exclude__ attributes."""
-        include = mcs.attributes.get('__include__', tuple())
-        exclude = mcs.attributes.get('__exclude__', tuple())
+    @staticmethod
+    def get_prepared_include_exclude(attributes):
+        """Return tuple with prepared __include__ and __exclude__ attributes.
+
+        :type attributes: dict
+        :rtype: tuple
+        """
+        attrs = dict()
+        for attr in ('__include__', '__exclude__'):
+            attrs[attr] = tuple([item.name for item in
+                                 attributes.get(attr, tuple())])
+        return attrs['__include__'], attrs['__exclude__']
+
+    @staticmethod
+    def check_include_exclude(attributes):
+        """Check __include__ and __exclude__ attributes.
+
+        :type attributes: dict
+        """
+        include = attributes.get('__include__', tuple())
+        exclude = attributes.get('__exclude__', tuple())
 
         if not isinstance(include, tuple):
             raise TypeError("Attribute __include__ must be a tuple.")
@@ -55,71 +74,80 @@ def check_include_exclude(mcs):
             raise AttributeError("Usage of __include__ and __exclude__ "
                                  "at the same time is prohibited.")
 
-        include_names = [item.name for item in include]
-        exclude_names = [item.name for item in exclude]
+    @staticmethod
+    def get_properties(attributes):
+        """Return tuple of names of defined properties.
 
-        mcs.chk_intersections(include_names, exclude_names)
-        mcs.match_unknown_attrs(include_names, exclude_names)
+        :type attributes: dict
+        :rtype: list
+        """
+        return [key for key, value in six.iteritems(attributes)
+                if isinstance(value, property)]
 
     @classmethod
-    def chk_intersections(mcs, include, exclude):
-        """Check whether intersections exist."""
-        intersections = mcs.get_intersections(include)
-        attr, intersections = ('__include__', intersections) \
-            if intersections \
-            else ('__exclude__', mcs.get_intersections(exclude))
-
-        if intersections:
-            raise AttributeError(
-                "It is not allowed to mention already defined properties: "
-                "{0} in {1} attributes.".format(", ".join(intersections),
-                                                attr))
+    def check_properties(mcs, attributes):
+        """Check whether intersections exist.
+
+        :type attributes: dict
+        """
+        include, exclude = mcs.get_prepared_include_exclude(attributes)
+
+        if include:
+            intersections = mcs.get_intersections(attributes, include)
+            attr = '__include__'
+        elif exclude:
+            intersections = mcs.get_intersections(attributes, exclude)
+            attr = '__exclude__'
+        else:
+            return None
+
+        if not intersections:
+            return None
+
+        raise AttributeError(
+            "It is not allowed to mention already defined properties: "
+            "{0} in {1} attributes.".format(", ".join(intersections), attr))
 
     @classmethod
-    def get_intersections(mcs, attr):
+    def get_intersections(mcs, attributes, attr):
         """Return intersection with defined properties if exists.
 
+        :type attributes: dict
         :type attr: list
         :rtype: list
         """
         if not attr:
             return []
-        return list(set(mcs.get_properties()).intersection(attr))
-
-    @classmethod
-    def match_unknown_attrs(mcs, include, exclude):
-        """Check about using nonexistent attributes."""
-        model_cls = mcs.attributes.get('__model_cls__')
-        unknown_attr = []
-        for item in include:
-            if not hasattr(model_cls, item):
-                unknown_attr.append(item)
-
-        for item in exclude:
-            if not hasattr(model_cls, item):
-                unknown_attr.append(item)
-
-        if unknown_attr:
-            raise AttributeError(
-                "Nonexistent attributes: {0}.".format(
-                    ", ".join(unknown_attr)))
+        properties = mcs.get_properties(attributes)
+        return list(set(properties).intersection(attr))
 
     @classmethod
-    def get_properties(mcs):
-        """Return list of names of defined properties.
+    def match_unknown_attrs(mcs, attributes):
+        """Check about using nonexistent attributes.
 
-        :rtype: list
+        :type attributes: dict
         """
-        return [key for key, value in six.iteritems(mcs.attributes)
-                if isinstance(value, property)]
+        model_cls = attributes.get('__model_cls__')
+        include, exclude = mcs.get_prepared_include_exclude(attributes)
+        attrs = include if include else exclude
+        unknown_attr = list()
+
+        for attr in attrs:
+            if not hasattr(model_cls, attr):
+                unknown_attr.append(attr)
+
+        if not unknown_attr:
+            return None
+
+        raise AttributeError(
+            "Nonexistent attributes: {0}.".format(", ".join(unknown_attr)))
 
 
 @six.add_metaclass(ContextViewMetaClass)
 class ContextView(object):
     """Contextual view class."""
 
     __model_cls__ = None
-    __model__ = None
     __include__ = tuple()
     __exclude__ = tuple()
     __fields__ = list()
@@ -133,7 +161,7 @@ def __init__(self, model):
             raise TypeError("\"{0}\" is not an instance of {1}".format(
                 model, self.__model_cls__))
 
-        self.__model__ = model
+        self._model = model
 
         if self.__include__:
             self._include()
@@ -143,21 +171,24 @@ def __init__(self, model):
             self._fields()
 
     def _include(self):
+        """Fill __fields__ out based on __include__."""
         for field in self.__include__:
-            value = getattr(self.__model__, field.name)
+            value = getattr(self._model, field.name)
             setattr(self, field.name, value)
             self.__fields__.append(field.name)
 
     def _exclude(self):
+        """Fill __fields__ out based on __exclude__."""
         exclude = [field.name for field in self.__exclude__]
-        for (field, value) in six.iteritems(self.__model__.get_data()):
+        for (field, value) in six.iteritems(self._model.get_data()):
             if field in exclude:
                 continue
             setattr(self, field, value)
             self.__fields__.append(field)
 
     def _fields(self):
-        for (field, value) in six.iteritems(self.__model__.get_data()):
+        """Fill __fields__ out based on full model data."""
+        for (field, value) in six.iteritems(self._model.get_data()):
             if field in self.__fields__:
                 continue
             setattr(self, field, value)

tests/test_context_view.py

@@ -39,7 +39,7 @@ def oid(self):
 
         :rtype: int
         """
-        return self.__model__.id << 8
+        return self._model.id << 8
 
     @property
     def photos(self):
@@ -48,7 +48,7 @@ def photos(self):
         :rtype: list
         """
         photos = []
-        for photo in self.__model__.photos:
+        for photo in self._model.photos:
             if not photo.public:
                 continue
             photo_data = PhotoPublicContext(photo).get_data()
@@ -62,7 +62,7 @@ def main_photo(self):
 
         :rtype: dict
         """
-        return PhotoPublicContext(self.__model__.main_photo).get_data()
+        return PhotoPublicContext(self._model.main_photo).get_data()
 
 
 class ProfilePrivateContext(views.ContextView):
@@ -76,7 +76,7 @@ def photos(self):
         :rtype: list
         """
         photos = []
-        for photo in self.__model__.photos:
+        for photo in self._model.photos:
             photo_data = PhotoPrivateContext(photo).get_data()
             if photo_data:
                 photos.append(photo_data)
@@ -88,7 +88,7 @@ def main_photo(self):
 
         :rtype: dict
         """
-        return PhotoPrivateContext(self.__model__.main_photo).get_data()
+        return PhotoPrivateContext(self._model.main_photo).get_data()
 
 
 class PhotoPublicContext(views.ContextView):
@@ -102,7 +102,7 @@ def oid(self):
 
         :rtype: int
         """
-        return self.__model__.id << 8
+        return self._model.id << 8
 
 
 class PhotoPrivateContext(views.ContextView):
@@ -273,7 +273,7 @@ class SomeContext(views.ContextView):
 
             @property
             def name(self):
-                return " + ".join((self.__model__.name, "postfix"))
+                return " + ".join((self._model.name, "postfix"))
 
         profile_within_context = SomeContext(self.profile)
         self.assertEqual(profile_within_context.name, 'John + postfix')