Encapsulate Link header behaviour

copitux · copitux · commit 0ea5b5c16b1e · 2012-03-04T10:36:55.000+01:00
diff --git a/pygithub3/core/link.py b/pygithub3/core/link.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+
+from urlparse import urlparse, parse_qs
+
+from .third_libs.link_header import parse_link_value
+
+class Link(str):
+
+    class Url(str):
+
+        @property
+        def query(self):
+            return urlparse(self).query
+
+        @property
+        def params(self):
+            return dict([
+                (param, values.pop())
+                for param, values in parse_qs(self.query).items()])
+
+    def __init__(self, object_):
+        super(Link, self).__init__(object_)
+        parsed = parse_link_value(self)
+        for url in parsed:
+            setattr(self, parsed[url]['rel'], Link.Url(url))
diff --git a/pygithub3/core/result.py b/pygithub3/core/result.py
@@ -3,10 +3,11 @@
 
 from urlparse import urlparse, parse_qs
 
-from .third_libs.link_header import parse_link_value
+from .link import Link
 
 
 class Method(object):
+    """ Lazy support """
 
     def __init__(self, method, request, **method_args):
         self.method = method
@@ -15,41 +16,36 @@ def __init__(self, method, request, **method_args):
         self.cache = {}
 
     def cached(func):
+        """ Decorator to don't do a request if it's cached """
         def wrapper(self, page=1):
             if str(page) in self.cache:
                 return self.cache[str(page)]
             return func(self, page)
         return wrapper
 
     def if_needs_lastpage(func):
-        def wrapper(self, response):
-            has_link = response.headers.get('link')
+        """ Decorator to set last page only if it can and it hasn't retrieved
+        before """
+        def wrapper(self, has_link):
             has_last_page = hasattr(self, 'last_page')
             if not has_last_page and has_link:
-                return func(self, response)
+                return func(self, has_link)
             elif not has_last_page and not has_link:
                 self.last_page = 1
         return wrapper
 
     @if_needs_lastpage
-    def __set_last_page_from(self, response):
-        link_parsed = parse_link_value(response.headers['link'])
-
-        def get_last(url):
-            url_rels = link_parsed[url]
-            return (url_rels.get('rel') == 'last')
-        url_last = filter(get_last, link_parsed)
-        query = urlparse(url_last.pop()).query
-        self.last_page = int(parse_qs(query).get('page').pop())
+    def __set_last_page_from(self, link_header):
+        """ Get and set last_page form link header """
+        link = Link(link_header)
+        self.last_page = int(link.last.params.get('page'))
 
     @cached
     def __call__(self, page=1):
-        all_args = self.args.copy()
-        all_args.update(page=page)
-        response = self.method(self.request, **all_args)
-        self.__set_last_page_from(response)
-        resource = self.request.resource
-        self.cache[str(page)] = resource.loads(response.content)
+        """ Call a real request """
+        response = self.method(page=page)
+        self.__set_last_page_from(response.headers.get('link'))
+        self.cache[str(page)] = self.resource.loads(response.content)
         return self.cache[str(page)]
 
     @property
@@ -60,10 +56,9 @@ def last(self):
 
 
 class Page(object):
-    """ """
+    """ Iterator of resources """
 
     def __init__(self, getter, page=1):
-        """ """
         self.getter = getter
         self.page = page
 
@@ -136,7 +131,8 @@ def __repr__(self):
 
 class Result(object):
     """
-    Result is a very lazy paginator. It only do a real request when is needed
+    Result is a very **lazy** paginator beacuse only do a real request when is
+    needed, besides it's **cached**, so never repeats a request.
 
     You have several ways to consume it
 
