Improve models

Now the models maps itself from json encoded
Then we can inherit it and change behaviour to use polymorphism into
resources ;)

1 files changed, 36 insertions, 16 deletions

diff --git a/pygithub3/models/base.py b/pygithub3/models/base.py
index 2f0cbd7..722d545 100644
--- 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 @@ class Model(object):
 
         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)