Abstract and decouple converters

copitux · akaihola · Oct 29, 2011 · Oct 29, 2011 · Nov 1, 2011 · Nov 1, 2011
commit d783e2580388b1c9d403959925fefdb967f765da
diff --git a/github3/converters.py b/github3/converters.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+#
+# author: David Medina
+from .core import Converter
+
+class Rawlizer(Converter):
+    """ Raw converter """
+
+    def inject(self, fake):
+        pass
+
+    def loads(self, raw_resource):
+        return raw_resource
+
+    def dumps(self):
+        pass
+
+class Json(Converter):
+    """ Json converter """
+
+    def __init__(self):
+        import json
+        self.parser = json
+
+    def inject(self, fake):
+        pass
+
+    def loads(self, raw_resource):
+        return self.parser.dumps(raw_resource)
+
+    def dumps(self):
+        pass
+
+class Modelizer(Converter):
+    """ Own model converter """
+
+    def __init__(self, model=None):
+        if model:
+            self.inject(model)
+
+    def _parse_date(self, string_date):
+        from datetime import datetime
+        try:
+            date = datetime.strptime(string_date, '%Y-%m-%dT%H:%M:%SZ')
+        except TypeError:
+            date = None
+
+        return date
+
+    def inject(self, model):
+        self.model = model
+
+    def _parse_map(self, model, raw_resource):
+        return Modelizer(model).loads(raw_resource)
+
+    def _parse_collection_map(self, model, raw_resources):
+        # Dict of resources (Ex: Gist file)
+        if getattr(raw_resources, 'items', False):
+            dict_map = {}
+            for key, raw_resource in raw_resources.items():
+                dict_map[key] = Modelizer(model).loads(raw_resource)
+            return dict_map
+        # list of resources
+        else:
+            return [Modelizer(model).loads(raw_resource)
+                    for raw_resource in raw_resources]
+
+    def loads(self, raw_resource):
+        attrs = {}
+        if not getattr(self, 'model', False):
+            raise NotImplementedError("%s needs model attr" %
+                self.__class__.__name__)
+        idl = self.model.idl()
+        attrs.update(
+            {attr: raw_resource[attr] for attr in idl.get('strs',())
+             if raw_resource.get(attr)})
+        attrs.update(
+            {attr: raw_resource[attr] for attr in idl.get('ints',())
+             if raw_resource.get(attr)})
+        attrs.update(
+            {attr: self._parse_date(raw_resource[attr])
+             for attr in idl.get('dates',()) if raw_resource.get(attr)})
+        attrs.update(
+            {attr: raw_resource[attr] for attr in idl.get('bools',())
+             if raw_resource.get(attr)})
+        attrs.update(
+            {attr: self._parse_map(model, raw_resource[attr])
+             for attr, model in idl.get('maps',{}).items()
+             if raw_resource.get(attr)})
+        attrs.update(
+            {attr: self._parse_collection_map(model, raw_resource[attr])
+             for attr, model in idl.get('collection_maps',{}).items()
+             if raw_resource.get(attr)})
+
+        return self.model(attrs)
+
+    def dumps(self, model):
+        # return JSON
+        pass
diff --git a/github3/core.py b/github3/core.py
@@ -49,65 +49,17 @@ def next(self):
                 self.page += 1
                 return content
 
-class Modelizer(object):
-    """ Converter json into model and vice versa """
+class Converter(object):
+    """ Abstract converter class """
 
-    def __init__(self, model):
-        self.model = model
-
-    def _parse_date(self, string_date):
-        from datetime import datetime
-        try:
-            date = datetime.strptime(string_date, '%Y-%m-%dT%H:%M:%SZ')
-        except TypeError:
-            date = None
-
-        return date
-
-    def _parse_map(self, model, raw_resource):
-        if model == 'self':
-            model = self.model
-
-        return Modelizer(model).loads(raw_resource)
-
-    def _parse_collection_map(self, model, raw_resources):
-        # Dict of resources (Ex: Gist file)
-        if getattr(raw_resources, 'items', False):
-            dict_map = {}
-            for key, raw_resource in raw_resources.items():
-                dict_map[key] = Modelizer(model).loads(raw_resource)
-            return dict_map
-        # list of resources
-        else:
-            return [Modelizer(model).loads(raw_resource)
-                    for raw_resource in raw_resources]
-
-    def loads(self, raw_resource):
-        attrs = {}
-        idl = self.model.idl()
-        attrs.update(
-            {attr: raw_resource[attr] for attr in idl.get('strs',())
-             if raw_resource.get(attr)})
-        attrs.update(
-            {attr: raw_resource[attr] for attr in idl.get('ints',())
-             if raw_resource.get(attr)})
-        attrs.update(
-            {attr: self._parse_date(raw_resource[attr])
-             for attr in idl.get('dates',()) if raw_resource.get(attr)})
-        attrs.update(
-            {attr: raw_resource[attr] for attr in idl.get('bools',())
-             if raw_resource.get(attr)})
-        attrs.update(
-            {attr: self._parse_map(model, raw_resource[attr])
-             for attr, model in idl.get('maps',{}).items()
-             if raw_resource.get(attr)})
-        attrs.update(
-            {attr: self._parse_collection_map(model, raw_resource[attr])
-             for attr, model in idl.get('collection_maps',{}).items()
-             if raw_resource.get(attr)})
-
-        return self.model(attrs)
+    def loads(self):
+        raise NotImplementedError("%s needs define '%s' method" %
+            (self.__class__.__name__, 'loads'))
 
     def dumps(self):
-        # return JSON
-        pass
+        raise NotImplementedError("%s needs define '%s' method" %
+            (self.__class__.__name__, 'dumps'))
+
+    def inject(self):
+        raise NotImplementedError("%s needs define '%s' method" %
+            (self.__class__.__name__, 'inject'))
diff --git a/github3/handlers/base.py b/github3/handlers/base.py
@@ -3,7 +3,8 @@
 #
 # author: David Medina
 
-from github3.core import Paginate, Modelizer
+from github3.core import Paginate
+from github3.converters import Modelizer
 
 class Handler(object):
     """ Handler base. Requests to API and modelize responses """
@@ -12,6 +13,12 @@ def __init__(self, gh):
         self._gh = gh
         super(Handler, self).__init__()
 
+    def _get_converter(self):
+        try:
+            return getattr(self, 'converter')
+        except AttributeError:
+            return Modelizer()
+
     def _bool(self, resource, **kwargs):
         """ Handler request to boolean response """
 
@@ -33,8 +40,9 @@ def _get_resources(self, resource, model=None, limit=None):
             for raw_resource in page:
                 if limit and counter > limit: break
                 counter += 1
-                yield Modelizer(model or self.model).loads(raw_resource)
-                #yield raw_resource
+                converter = self._get_converter()
+                converter.inject(model)
+                yield converter.loads(raw_resource)
             else:
                 continue
             break
@@ -43,4 +51,7 @@ def _get_resource(self, resource, model=None):
         """ Handler request to single resource """
 
         raw_resource = self._gh.get(resource)
-        return Modelizer(model or self.model).loads(raw_resource)
+        converter = self._get_converter()
+        converter.inject(model)
+        return converter.loads(raw_resource)
+