pagination.py

#!/usr/bin/env python
import unittest
from math import ceil
from pdb import set_trace as bp

class Page(object):
    def __init__(self, number, current):
        self.number = number
        self.current = current

class Pagination(object):
    def __init__(self, number_page, current_page,\
                 number_left=5, number_pagination=10):
        self.number_page = number_page
        self.current_page = current_page
        self.number_left = number_left
        self.number_pagination = number_pagination

        self._idx = 0

    def __iter__(self):
        return self

    def next(self):
        start = max(self.current_page - self.number_left, 1)

        to_right = self.number_pagination - self.number_left - 1
        current_page_to_right = self.current_page + to_right
        to_right_overflow = current_page_to_right - self.number_page
        end = min(self.number_page,\
                  max(current_page_to_right, self.number_pagination))

        if 0 < to_right_overflow:
            start -= to_right_overflow

        if self.number_page < self.number_pagination:
            start = 1
            end = self.number_page


        if end > self._idx:
            page = Page(self._idx + start,\
                        self.current_page == self._idx + start)
        else:
            self._idx = 0
            raise StopIteration()

        self._idx += 1

        return page

class PaginatorMock(object):
    def __init__(self, object_list, per_page, orphans=0,\
                 allow_empty_first_page=True):
        self.object_list = object_list
        self.per_page = per_page

    @property
    def count(self):
        return len(self.object_list)

    @property
    def num_pages(self):
        hits = max(1, self.count)

        return int(ceil(hits / float(self.per_page)))

    @property
    def page_range(self):
        pass


class PaginationTest(unittest.TestCase):
    """
    |1|2|3|4|*5*|6|7|8|9|10|...|100|
    """
    def test_pagination(self):
        paginator = PaginatorMock(xrange(0, 1000), 10)
        p = Pagination(paginator.num_pages, 2, 5, 10)
        

        assert 1 == p.next().number
        assert True == p.next().current
        assert 3 == p.next().number
        assert 4 == p.next().number
        assert 5 == p.next().number
        assert 6 == p.next().number
        assert 7 == p.next().number
        assert 8 == p.next().number
        assert 9 == p.next().number
        assert 10 == p.next().number

    def test_pagination2(self):
        paginator = PaginatorMock(xrange(0, 1000), 10)
        p = Pagination(paginator.num_pages, 2, 5, 10)
        
        for page in p:
            if 2 == page.number:
                assert True == page.current
            else:
                assert False == page.current

    def test_pagination3(self):
        paginator = PaginatorMock(xrange(0, 110), 10)
        p = Pagination(paginator.num_pages, 8, 5, 10)
        
        for i in range(2, 13):
            page = p.next()
            assert i == page.number

    def test_pagination_number_pages_letter_number_pagination(self):
        paginator = PaginatorMock(xrange(0, 90), 10)
        p = Pagination(paginator.num_pages, 8, 5, 10)
        
        for i in range(1, 10):
            page = p.next()
            assert i == page.number

    def test_pagination_to_right_override(self):
        paginator = PaginatorMock(xrange(0, 100), 10)
        p = Pagination(paginator.num_pages, 7, 5, 10)
        

        for i in range(1, 11):
            page = p.next()
            assert i == page.number
        
if "__main__" == __name__:
    unittest.main()