Improve models

copitux · copitux · commit d61d25f74941 · 2012-02-04T02:30:52.000+01:00
Now the models maps itself from json encoded
Then we can inherit it and change behaviour to use polymorphism into
resources ;)
diff --git a/pygithub3/core/resources/users/emails.py b/pygithub3/core/resources/users/emails.py
@@ -2,8 +2,15 @@
 # -*- encoding: utf-8 -*-
 
 from . import Resource
-#from pygithub3.models.
+from pygithub3.models.base import Raw
 
 
 class List(Resource):
-    pass
+
+    model = Raw
+
+    def validate(self):
+        pass
+
+    def set_uri(self):
+        return 'user/emails'
diff --git a/pygithub3/models/base.py b/pygithub3/models/base.py
@@ -1,25 +1,38 @@
 #!/usr/bin/env python
 # -*- encoding: utf-8 -*-
 
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
 
 class Model(object):
 
-    dates = ()
-    maps = {}
-    collection_maps = {}
+    _dates = ()
+    _maps = {}
+    _collection_maps = {}
 
     def __init__(self, attrs):
         """ """
-        self.attrs = attrs
+        self._attrs = attrs
+        self.__set_attrs()
+
+    def __set_attrs(self):
+        for attr in self._attrs:
+            setattr(self, attr, self._attrs[attr])
 
-    def __getattr__(self, name):
-        try:
-            return self.attrs[name]
-        except KeyError:
-            raise AttributeError
+    @classmethod
+    def loads(self, json_content):
+        resource_chunk = json.loads(json_content)
+        if not hasattr(resource_chunk, 'items'):
+            return [self.__load(raw_resource)
+                    for raw_resource in resource_chunk]
+        else:
+            return self.__load(resource_chunk)
 
     @classmethod
-    def loads(self, raw_resource):
+    def __load(self, raw_resource):
         def parse_date(string_date):
             from datetime import datetime
             try:
@@ -30,29 +43,36 @@ def parse_date(string_date):
 
         def parse_map(model, raw_resource):
             if hasattr(raw_resource, 'items'):
-                return model.loads(raw_resource)
+                return model.__load(raw_resource)
 
         def parse_collection_map(model, raw_resources):
             # Dict of resources (Ex: Gist file)
             if hasattr(raw_resources, 'items'):
                 dict_map = {}
                 for key, raw_resource in raw_resources.items():
-                    dict_map[key] = model.loads(raw_resource)
+                    dict_map[key] = model.__load(raw_resource)
                 return dict_map
             # list of resources
             elif hasattr(raw_resources, '__iter__'):
-                return [model.loads(raw_resource)
+                return [model.__load(raw_resource)
                         for raw_resource in raw_resources]
         raw_resource.update(
             {attr: parse_date(raw_resource[attr])
-             for attr in self.dates if attr in raw_resource})
+             for attr in self._dates if attr in raw_resource})
         raw_resource.update(
             {attr: parse_map(model, raw_resource[attr])
-             for attr, model in self.maps.items()
+             for attr, model in self._maps.items()
              if attr in raw_resource})
         raw_resource.update(
             {attr: parse_collection_map(model, raw_resource[attr])
-             for attr, model in self.collection_maps.items()
+             for attr, model in self._collection_maps.items()
              if attr in raw_resource})
 
         return self(raw_resource)
+
+
+class Raw(Model):
+
+    @classmethod
+    def loads(self, json_content):
+        return json.loads(json_content)
diff --git a/pygithub3/models/users.py b/pygithub3/models/users.py
@@ -15,8 +15,8 @@ def __str__(self):
 class User(Model):
     """ """
 
-    maps = {'plan': Plan}
-    dates = ('created_at', )
+    _maps = {'plan': Plan}
+    _dates = ('created_at', )
 
     def __str__(self):
         return '<User (%s)>' % getattr(self, 'login', '')
