webhelpers: replaced paginate library with custom lib

pkgs/python-packages.nix

@@ -1829,7 +1829,6 b' self: super: {'
       self."venusian"
       self."weberror"
       self."webhelpers2"
-      self."webhelpers"
       self."webob"
       self."whoosh"
       self."wsgiref"
@@ -2212,20 +2211,6 b' self: super: {'
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  "webhelpers" = super.buildPythonPackage {
-    name = "webhelpers-1.3";
-    doCheck = false;
-    propagatedBuildInputs = [
-      self."markupsafe"
-    ];
-    src = fetchurl {
-      url = "https://files.pythonhosted.org/packages/ee/68/4d07672821d514184357f1552f2dad923324f597e722de3b016ca4f7844f/WebHelpers-1.3.tar.gz";
-      sha256 = "10x5i82qdkrvyw18gsybwggfhfpl869siaab89vnndi9x62g51pa";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.bsdOriginal ];
-    };
-  };
   "webhelpers2" = super.buildPythonPackage {
     name = "webhelpers2-2.0";
     doCheck = false;

requirements.txt

@@ -71,7 +71,6 b' urlobject==2.4.3'
 venusian==1.2.0
 weberror==0.10.3
 webhelpers2==2.0
-webhelpers==1.3
 webob==1.8.5
 whoosh==2.7.4
 wsgiref==0.1.2

rhodecode/apps/admin/views/audit_logs.py

@@ -28,7 +28,7 b' from rhodecode.model.db import joinedloa'
 from rhodecode.lib.user_log_filter import user_log_filter
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.lib.utils2 import safe_int
-from rhodecode.lib.helpers import Page
+from rhodecode.lib.helpers import SqlPage
 
 log = logging.getLogger(__name__)
 
@@ -62,13 +62,16 b' class AdminAuditLogsView(BaseAppView):'
 
         p = safe_int(self.request.GET.get('page', 1), 1)
 
-        def url_generator(**kw):
+        def url_generator(page_num):
+            query_params = {
+                'page': page_num
+            }
             if c.search_term:
-                kw['filter'] = c.search_term
-            return self.request.current_route_path(_query=kw)
+                query_params['filter'] = c.search_term
+            return self.request.current_route_path(_query=query_params)
 
-        c.audit_logs = Page(users_log, page=p, items_per_page=10,
-                            url=url_generator)
+        c.audit_logs = SqlPage(users_log, page=p, items_per_page=10,
+                               url_maker=url_generator)
         return self._get_template_context(c)
 
     @LoginRequired()

rhodecode/apps/admin/views/users.py

@@ -44,6 +44,7 b' from rhodecode.lib.ext_json import json'
 from rhodecode.lib.auth import (
     LoginRequired, HasPermissionAllDecorator, CSRFRequired)
 from rhodecode.lib import helpers as h
+from rhodecode.lib.helpers import SqlPage
 from rhodecode.lib.utils2 import safe_int, safe_unicode, AttributeDict
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.forms import (
@@ -1228,13 +1229,16 b' class UsersView(UserAppView):'
         filter_term = self.request.GET.get('filter')
         user_log = UserModel().get_user_log(c.user, filter_term)
 
-        def url_generator(**kw):
+        def url_generator(page_num):
+            query_params = {
+                'page': page_num
+            }
             if filter_term:
-                kw['filter'] = filter_term
-            return self.request.current_route_path(_query=kw)
+                query_params['filter'] = filter_term
+            return self.request.current_route_path(_query=query_params)
 
-        c.audit_logs = h.Page(
-            user_log, page=p, items_per_page=10, url=url_generator)
+        c.audit_logs = SqlPage(
+            user_log, page=p, items_per_page=10, url_maker=url_generator)
         c.filter_term = filter_term
         return self._get_template_context(c)
 

rhodecode/apps/journal/views.py

@@ -34,7 +34,7 b' from rhodecode.model.db import ('
     or_, joinedload, Repository, UserLog, UserFollowing, User, UserApiKeys)
 from rhodecode.model.meta import Session
 import rhodecode.lib.helpers as h
-from rhodecode.lib.helpers import Page
+from rhodecode.lib.helpers import SqlPage
 from rhodecode.lib.user_log_filter import user_log_filter
 from rhodecode.lib.auth import LoginRequired, NotAnonymous, CSRFRequired, HasRepoPermissionAny
 from rhodecode.lib.utils2 import safe_int, AttributeDict, md5_safe
@@ -232,15 +232,15 b' class JournalView(BaseAppView):'
 
         journal = self._get_journal_data(following, c.search_term)
 
-        def url_generator(**kw):
+        def url_generator(page_num):
             query_params = {
+                'page': page_num,
                 'filter': c.search_term
             }
-            query_params.update(kw)
             return self.request.current_route_path(_query=query_params)
 
-        c.journal_pager = Page(
-            journal, page=p, items_per_page=20, url=url_generator)
+        c.journal_pager = SqlPage(
+            journal, page=p, items_per_page=20, url_maker=url_generator)
         c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)
 
         c.journal_data = render(
@@ -333,13 +333,14 b' class JournalView(BaseAppView):'
 
         journal = self._get_journal_data(c.following, c.search_term)
 
-        def url_generator(**kw):
-            query_params = {}
-            query_params.update(kw)
+        def url_generator(page_num):
+            query_params = {
+                'page': page_num
+            }
             return self.request.current_route_path(_query=query_params)
 
-        c.journal_pager = Page(
-            journal, page=p, items_per_page=20, url=url_generator)
+        c.journal_pager = SqlPage(
+            journal, page=p, items_per_page=20, url_maker=url_generator)
         c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)
 
         c.journal_data = render(

rhodecode/apps/my_account/views/my_account_notifications.py

@@ -28,7 +28,7 b' from rhodecode.apps._base import BaseApp'
 from rhodecode.lib.auth import LoginRequired, NotAnonymous, CSRFRequired
 
 from rhodecode.lib import helpers as h
-from rhodecode.lib.helpers import Page
+from rhodecode.lib.helpers import SqlPage
 from rhodecode.lib.utils2 import safe_int
 from rhodecode.model.db import Notification
 from rhodecode.model.notification import NotificationModel
@@ -74,13 +74,16 b' class MyAccountNotificationsView(BaseApp'
 
         p = safe_int(self.request.GET.get('page', 1), 1)
 
-        def url_generator(**kw):
+        def url_generator(page_num):
+            query_params = {
+                'page': page_num
+            }
             _query = self.request.GET.mixed()
-            _query.update(kw)
-            return self.request.current_route_path(_query=_query)
+            query_params.update(_query)
+            return self.request.current_route_path(_query=query_params)
 
-        c.notifications = Page(notifications, page=p, items_per_page=10,
-                               url=url_generator)
+        c.notifications = SqlPage(notifications, page=p, items_per_page=10,
+                                  url_maker=url_generator)
 
         c.unread_type = 'unread'
         c.all_type = 'all'

rhodecode/apps/repository/views/repo_audit_logs.py

@@ -22,6 +22,7 b' import logging'
 from pyramid.view import view_config
 
 from rhodecode.apps._base import RepoAppView
+from rhodecode.lib.helpers import SqlPage
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.utils2 import safe_int
@@ -33,8 +34,6 b' log = logging.getLogger(__name__)'
 class AuditLogsView(RepoAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
-
-
         return c
 
     @LoginRequired()
@@ -54,12 +53,15 b' class AuditLogsView(RepoAppView):'
         filter_term = self.request.GET.get('filter')
         user_log = RepoModel().get_repo_log(c.db_repo, filter_term)
 
-        def url_generator(**kw):
+        def url_generator(page_num):
+            query_params = {
+                'page': page_num
+            }
             if filter_term:
-                kw['filter'] = filter_term
-            return self.request.current_route_path(_query=kw)
+                query_params['filter'] = filter_term
+            return self.request.current_route_path(_query=query_params)
 
-        c.audit_logs = h.Page(
-            user_log, page=p, items_per_page=10, url=url_generator)
+        c.audit_logs = SqlPage(
+            user_log, page=p, items_per_page=10, url_maker=url_generator)
         c.filter_term = filter_term
         return self._get_template_context(c)

rhodecode/apps/repository/views/repo_changelog.py

@@ -121,9 +121,16 b' class RepoChangelogView(RepoAppView):'
             self, c, collection, page, chunk_size, branch_name=None,
             dynamic=False, f_path=None, commit_id=None):
 
-        def url_generator(**kw):
-            query_params = {}
-            query_params.update(kw)
+        def url_generator(page_num):
+            query_params = {
+                'page': page_num
+            }
+
+            if branch_name:
+                query_params.update({
+                    'branch': branch_name
+                })
+
             if f_path:
                 # changelog for file
                 return h.route_path(
@@ -139,8 +146,7 b' class RepoChangelogView(RepoAppView):'
         c.total_cs = len(collection)
         c.showing_commits = min(chunk_size, c.total_cs)
         c.pagination = RepoPage(collection, page=page, item_count=c.total_cs,
-                                items_per_page=chunk_size, branch=branch_name,
-                                url=url_generator)
+                                items_per_page=chunk_size, url_maker=url_generator)
 
         c.next_page = c.pagination.next_page
         c.prev_page = c.pagination.previous_page

rhodecode/apps/repository/views/repo_summary.py

@@ -56,11 +56,11 b' class RepoSummaryView(RepoAppView):'
         p = safe_int(self.request.GET.get('page'), 1)
         size = safe_int(self.request.GET.get('size'), 10)
 
-        def url_generator(**kw):
+        def url_generator(page_num):
             query_params = {
+                'page': page_num,
                 'size': size
             }
-            query_params.update(kw)
             return h.route_path(
                 'repo_summary_commits',
                 repo_name=c.rhodecode_db_repo.repo_name, _query=query_params)
@@ -73,7 +73,7 b' class RepoSummaryView(RepoAppView):'
             collection = self.rhodecode_vcs_repo
 
         c.repo_commits = h.RepoPage(
-            collection, page=p, items_per_page=size, url=url_generator)
+            collection, page=p, items_per_page=size, url_maker=url_generator)
         page_ids = [x.raw_id for x in c.repo_commits]
         c.comments = self.db_repo.get_comments(page_ids)
         c.statuses = self.db_repo.statuses(page_ids)

rhodecode/apps/search/views.py

@@ -59,11 +59,19 b' def perform_search(request, tmpl_context'
     except validation_schema.Invalid as e:
         errors = e.children
 
-    def url_generator(**kw):
+    def url_generator(page_num):
         q = urllib.quote(safe_str(search_query))
-        return update_params(
-            "?q=%s&type=%s&max_lines=%s&sort=%s" % (
-                q, safe_str(search_type), search_max_lines, search_sort), **kw)
+
+        query_params = {
+            'page': page_num,
+            'q': q,
+            'type': safe_str(search_type),
+            'max_lines': search_max_lines,
+            'sort': search_sort
+        }
+
+        return '?' + urllib.urlencode(query_params)
+
 
     c = tmpl_context
     search_query = search_params.get('search_query')
@@ -82,7 +90,7 b' def perform_search(request, tmpl_context'
             formatted_results = Page(
                 search_result['results'], page=requested_page,
                 item_count=search_result['count'],
-                items_per_page=page_limit, url=url_generator)
+                items_per_page=page_limit, url_maker=url_generator)
         finally:
             searcher.cleanup()
 
@@ -100,7 +108,6 b' def perform_search(request, tmpl_context'
     c.perm_user = c.auth_user
     c.repo_name = repo_name
     c.repo_group_name = repo_group_name
-    c.url_generator = url_generator
     c.errors = errors
     c.formatted_results = formatted_results
     c.runtime = execution_time

rhodecode/integrations/views.py

@@ -27,11 +27,11 b' from pyramid.httpexceptions import HTTPF'
 from rhodecode.integrations import integration_type_registry
 from rhodecode.apps._base import BaseAppView
 from rhodecode.apps._base.navigation import navigation_list
-from rhodecode.lib.paginate import PageURL
 from rhodecode.lib.auth import (
     LoginRequired, CSRFRequired, HasPermissionAnyDecorator,
     HasRepoPermissionAnyDecorator, HasRepoGroupPermissionAnyDecorator)
 from rhodecode.lib.utils2 import safe_int
+from rhodecode.lib.helpers import Page
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import Repository, RepoGroup, Session, Integration
 from rhodecode.model.scm import ScmModel
@@ -219,11 +219,16 b' class IntegrationSettingsViewBase(BaseAp'
             key=lambda x: getattr(x[1], sort_field),
             reverse=(sort_dir == 'desc'))
 
-        page_url = PageURL(self.request.path, self.request.GET)
+        def url_generator(page_num):
+            query_params = {
+                'page': page_num
+            }
+            return self.request.current_route_path(_query=query_params)
+
         page = safe_int(self.request.GET.get('page', 1), 1)
 
-        integrations = h.Page(
-            integrations, page=page, items_per_page=10, url=page_url)
+        integrations = Page(
+            integrations, page=page, items_per_page=10, url_maker=url_generator)
 
         c.rev_sort_dir = sort_dir != 'desc' and 'desc' or 'asc'
 

rhodecode/lib/helpers.py

@@ -75,7 +75,7 b' from webhelpers2.html.tags import ('
 from webhelpers2.number import format_byte_size
 
 from rhodecode.lib.action_parser import action_parser
-from rhodecode.lib.paginate import Page
+from rhodecode.lib.pagination import Page, RepoPage, SqlPage
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils import repo_name_slug, get_custom_lexer
 from rhodecode.lib.utils2 import (
@@ -1309,94 +1309,6 b' def gravatar_url(email_address, size=30,'
         return initials_gravatar(email_address, '', '', size=size)
 
 
-
-
-#==============================================================================
-# REPO PAGER, PAGER FOR REPOSITORY
-#==============================================================================
-class RepoPage(Page):
-
-    def __init__(self, collection, page=1, items_per_page=20,
-                 item_count=None, url=None, **kwargs):
-
-        """Create a "RepoPage" instance. special pager for paging
-        repository
-        """
-        self._url_generator = url
-
-        # Safe the kwargs class-wide so they can be used in the pager() method
-        self.kwargs = kwargs
-
-        # Save a reference to the collection
-        self.original_collection = collection
-
-        self.collection = collection
-
-        # The self.page is the number of the current page.
-        # The first page has the number 1!
-        try:
-            self.page = int(page)  # make it int() if we get it as a string
-        except (ValueError, TypeError):
-            self.page = 1
-
-        self.items_per_page = items_per_page
-
-        # Unless the user tells us how many items the collections has
-        # we calculate that ourselves.
-        if item_count is not None:
-            self.item_count = item_count
-        else:
-            self.item_count = len(self.collection)
-
-        # Compute the number of the first and last available page
-        if self.item_count > 0:
-            self.first_page = 1
-            self.page_count = int(math.ceil(float(self.item_count) /
-                                            self.items_per_page))
-            self.last_page = self.first_page + self.page_count - 1
-
-            # Make sure that the requested page number is the range of
-            # valid pages
-            if self.page > self.last_page:
-                self.page = self.last_page
-            elif self.page < self.first_page:
-                self.page = self.first_page
-
-            # Note: the number of items on this page can be less than
-            #       items_per_page if the last page is not full
-            self.first_item = max(0, (self.item_count) - (self.page *
-                                                          items_per_page))
-            self.last_item = ((self.item_count - 1) - items_per_page *
-                              (self.page - 1))
-
-            self.items = list(self.collection[self.first_item:self.last_item + 1])
-
-            # Links to previous and next page
-            if self.page > self.first_page:
-                self.previous_page = self.page - 1
-            else:
-                self.previous_page = None
-
-            if self.page < self.last_page:
-                self.next_page = self.page + 1
-            else:
-                self.next_page = None
-
-        # No items available
-        else:
-            self.first_page = None
-            self.page_count = 0
-            self.last_page = None
-            self.first_item = None
-            self.last_item = None
-            self.previous_page = None
-            self.next_page = None
-            self.items = []
-
-        # This is a subclass of the 'list' type. Initialise the list now.
-        list.__init__(self, reversed(self.items))
-
-
 def breadcrumb_repo_link(repo):
     """
     Makes a breadcrumbs path link to repo

rhodecode/lib/pagination.py

@@ -1,5 +1,882 b''
 # -*- coding: utf-8 -*-
 
+# Copyright (c) 2007-2012 Christoph Haas <[e-mail]>
+# NOTE: MIT license based code, backported and edited by RhodeCode GmbH
+
+"""
+paginate: helps split up large collections into individual pages
+================================================================
+
+What is pagination?
+---------------------
+
+This module helps split large lists of items into pages. The user is shown one page at a time and
+can navigate to other pages. Imagine you are offering a company phonebook and let the user search
+the entries. The entire search result may contains 23 entries but you want to display no more than
+10 entries at once. The first page contains entries 1-10, the second 11-20 and the third 21-23.
+Each "Page" instance represents the items of one of these three pages.
+
+See the documentation of the "Page" class for more information.
+
+How do I use it?
+------------------
+
+A page of items is represented by the *Page* object. A *Page* gets initialized with these arguments:
+
+- The collection of items to pick a range from. Usually just a list.
+- The page number you want to display. Default is 1: the first page.
+
+Now we can make up a collection and create a Page instance of it::
+
+    # Create a sample collection of 1000 items
+    >> my_collection = range(1000)
+
+    # Create a Page object for the 3rd page (20 items per page is the default)
+    >> my_page = Page(my_collection, page=3)
+
+    # The page object can be printed as a string to get its details
+    >> str(my_page)
+    Page:
+    Collection type:  <type 'range'>
+    Current page:     3
+    First item:       41
+    Last item:        60
+    First page:       1
+    Last page:        50
+    Previous page:    2
+    Next page:        4
+    Items per page:   20
+    Number of items:  1000
+    Number of pages:  50
+
+    # Print a list of items on the current page
+    >> my_page.items
+    [40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]
+
+    # The *Page* object can be used as an iterator:
+    >> for my_item in my_page: print(my_item)
+    40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
+
+    # The .pager() method returns an HTML fragment with links to surrounding pages.
+    >> my_page.pager(url="http://example.org/foo/page=$page")
+
+    <a href="http://example.org/foo/page=1">1</a>
+    <a href="http://example.org/foo/page=2">2</a>
+    3
+    <a href="http://example.org/foo/page=4">4</a>
+    <a href="http://example.org/foo/page=5">5</a>
+    ..
+    <a href="http://example.org/foo/page=50">50</a>'
+
+    # Without the HTML it would just look like:
+    # 1 2 [3] 4 5 .. 50
+
+    # The pager can be customized:
+    >> my_page.pager('$link_previous ~3~ $link_next (Page $page of $page_count)',
+                     url="http://example.org/foo/page=$page")
+
+    <a href="http://example.org/foo/page=2">&lt;</a>
+    <a href="http://example.org/foo/page=1">1</a>
+    <a href="http://example.org/foo/page=2">2</a>
+    3
+    <a href="http://example.org/foo/page=4">4</a>
+    <a href="http://example.org/foo/page=5">5</a>
+    <a href="http://example.org/foo/page=6">6</a>
+    ..
+    <a href="http://example.org/foo/page=50">50</a>
+    <a href="http://example.org/foo/page=4">&gt;</a>
+    (Page 3 of 50)
+
+    # Without the HTML it would just look like:
+    # 1 2 [3] 4 5 6 .. 50 > (Page 3 of 50)
+
+    # The url argument to the pager method can be omitted when an url_maker is
+    # given during instantiation:
+    >> my_page = Page(my_collection, page=3,
+                      url_maker=lambda p: "http://example.org/%s" % p)
+    >> page.pager()
+
+There are some interesting parameters that customize the Page's behavior. See the documentation on
+``Page`` and ``Page.pager()``.
+
+
+Notes
+-------
+
+Page numbers and item numbers start at 1. This concept has been used because users expect that the
+first page has number 1 and the first item on a page also has number 1. So if you want to use the
+page's items by their index number please note that you have to subtract 1.
+"""
+
+import re
+import sys
+from string import Template
+from webhelpers2.html import literal
+
+# are we running at least python 3.x ?
+PY3 = sys.version_info[0] >= 3
+
+if PY3:
+    unicode = str
+
+
+def make_html_tag(tag, text=None, **params):
+    """Create an HTML tag string.
+
+    tag
+        The HTML tag to use (e.g. 'a', 'span' or 'div')
+
+    text
+        The text to enclose between opening and closing tag. If no text is specified then only
+        the opening tag is returned.
+
+    Example::
+        make_html_tag('a', text="Hello", href="/another/page")
+        -> <a href="/another/page">Hello</a>
+
+    To use reserved Python keywords like "class" as a parameter prepend it with
+    an underscore. Instead of "class='green'" use "_class='green'".
+
+    Warning: Quotes and apostrophes are not escaped."""
+    params_string = ""
+
+    # Parameters are passed. Turn the dict into a string like "a=1 b=2 c=3" string.
+    for key, value in sorted(params.items()):
+        # Strip off a leading underscore from the attribute's key to allow attributes like '_class'
+        # to be used as a CSS class specification instead of the reserved Python keyword 'class'.
+        key = key.lstrip("_")
+
+        params_string += u' {0}="{1}"'.format(key, value)
+
+    # Create the tag string
+    tag_string = u"<{0}{1}>".format(tag, params_string)
+
+    # Add text and closing tag if required.
+    if text:
+        tag_string += u"{0}</{1}>".format(text, tag)
+
+    return tag_string
+
+
+# Since the items on a page are mainly a list we subclass the "list" type
+class _Page(list):
+    """A list/iterator representing the items on one page of a larger collection.
+
+    An instance of the "Page" class is created from a _collection_ which is any
+    list-like object that allows random access to its elements.
+
+    The instance works as an iterator running from the first item to the last item on the given
+    page. The Page.pager() method creates a link list allowing the user to go to other pages.
+
+    A "Page" does not only carry the items on a certain page. It gives you additional information
+    about the page in these "Page" object attributes:
+
+    item_count
+        Number of items in the collection
+
+        **WARNING:** Unless you pass in an item_count, a count will be
+        performed on the collection every time a Page instance is created.
+
+    page
+        Number of the current page
+
+    items_per_page
+        Maximal number of items displayed on a page
+
+    first_page
+        Number of the first page - usually 1 :)
+
+    last_page
+        Number of the last page
+
+    previous_page
+        Number of the previous page. If this is the first page it returns None.
+
+    next_page
+        Number of the next page. If this is the last page it returns None.
+
+    page_count
+        Number of pages
+
+    items
+        Sequence/iterator of items on the current page
+
+    first_item
+        Index of first item on the current page - starts with 1
+
+    last_item
+        Index of last item on the current page
+    """
+
+    def __init__(
+            self,
+            collection,
+            page=1,
+            items_per_page=20,
+            item_count=None,
+            wrapper_class=None,
+            url_maker=None,
+            bar_size=10,
+            **kwargs
+    ):
+        """Create a "Page" instance.
+
+        Parameters:
+
+        collection
+            Sequence representing the collection of items to page through.
+
+        page
+            The requested page number - starts with 1. Default: 1.
+
+        items_per_page
+            The maximal number of items to be displayed per page.
+            Default: 20.
+
+        item_count (optional)
+            The total number of items in the collection - if known.
+            If this parameter is not given then the paginator will count
+            the number of elements in the collection every time a "Page"
+            is created. Giving this parameter will speed up things. In a busy
+            real-life application you may want to cache the number of items.
+
+        url_maker (optional)
+            Callback to generate the URL of other pages, given its numbers.
+            Must accept one int parameter and return a URI string.
+
+        bar_size
+            maximum size of rendered pages numbers within radius
+
+        """
+        if collection is not None:
+            if wrapper_class is None:
+                # Default case. The collection is already a list-type object.
+                self.collection = collection
+            else:
+                # Special case. A custom wrapper class is used to access elements of the collection.
+                self.collection = wrapper_class(collection)
+        else:
+            self.collection = []
+
+        self.collection_type = type(collection)
+
+        if url_maker is not None:
+            self.url_maker = url_maker
+        else:
+            self.url_maker = self._default_url_maker
+        self.bar_size = bar_size
+        # Assign kwargs to self
+        self.kwargs = kwargs
+
+        # The self.page is the number of the current page.
+        # The first page has the number 1!
+        try:
+            self.page = int(page)  # make it int() if we get it as a string
+        except (ValueError, TypeError):
+            self.page = 1
+        # normally page should be always at least 1 but the original maintainer
+        # decided that for empty collection and empty page it can be...0? (based on tests)
+        # preserving behavior for BW compat
+        if self.page < 1:
+            self.page = 1
+
+        self.items_per_page = items_per_page
+
+        # We subclassed "list" so we need to call its init() method
+        # and fill the new list with the items to be displayed on the page.
+        # We use list() so that the items on the current page are retrieved
+        # only once. In an SQL context that could otherwise lead to running the
+        # same SQL query every time items would be accessed.
+        # We do this here, prior to calling len() on the collection so that a
+        # wrapper class can execute a query with the knowledge of what the
+        # slice will be (for efficiency) and, in the same query, ask for the
+        # total number of items and only execute one query.
+        try:
+            first = (self.page - 1) * items_per_page
+            last = first + items_per_page
+            self.items = list(self.collection[first:last])
+        except TypeError:
+            raise TypeError(
+                "Your collection of type {} cannot be handled "
+                "by paginate.".format(type(self.collection))
+            )
+
+        # Unless the user tells us how many items the collections has
+        # we calculate that ourselves.
+        if item_count is not None:
+            self.item_count = item_count
+        else:
+            self.item_count = len(self.collection)
+
+        # Compute the number of the first and last available page
+        if self.item_count > 0:
+            self.first_page = 1
+            self.page_count = ((self.item_count - 1) // self.items_per_page) + 1
+            self.last_page = self.first_page + self.page_count - 1
+
+            # Make sure that the requested page number is the range of valid pages
+            if self.page > self.last_page:
+                self.page = self.last_page
+            elif self.page < self.first_page:
+                self.page = self.first_page
+
+            # Note: the number of items on this page can be less than
+            #       items_per_page if the last page is not full
+            self.first_item = (self.page - 1) * items_per_page + 1
+            self.last_item = min(self.first_item + items_per_page - 1, self.item_count)
+
+            # Links to previous and next page
+            if self.page > self.first_page:
+                self.previous_page = self.page - 1
+            else:
+                self.previous_page = None
+
+            if self.page < self.last_page:
+                self.next_page = self.page + 1
+            else:
+                self.next_page = None
+
+        # No items available
+        else:
+            self.first_page = None
+            self.page_count = 0
+            self.last_page = None
+            self.first_item = None
+            self.last_item = None
+            self.previous_page = None
+            self.next_page = None
+            self.items = []
+
+        # This is a subclass of the 'list' type. Initialise the list now.
+        list.__init__(self, self.items)
+
+    def __str__(self):
+        return (
+            "Page:\n"
+            "Collection type:        {0.collection_type}\n"
+            "Current page:           {0.page}\n"
+            "First item:             {0.first_item}\n"
+            "Last item:              {0.last_item}\n"
+            "First page:             {0.first_page}\n"
+            "Last page:              {0.last_page}\n"
+            "Previous page:          {0.previous_page}\n"
+            "Next page:              {0.next_page}\n"
+            "Items per page:         {0.items_per_page}\n"
+            "Total number of items:  {0.item_count}\n"
+            "Number of pages:        {0.page_count}\n"
+        ).format(self)
+
+    def __repr__(self):
+        return "<paginate.Page: Page {0}/{1}>".format(self.page, self.page_count)
+
+    def pager(
+            self,
+            tmpl_format="~2~",
+            url=None,
+            show_if_single_page=False,
+            separator=" ",
+            symbol_first="&lt;&lt;",
+            symbol_last="&gt;&gt;",
+            symbol_previous="&lt;",
+            symbol_next="&gt;",
+            link_attr=None,
+            curpage_attr=None,
+            dotdot_attr=None,
+            link_tag=None,
+    ):
+        """
+        Return string with links to other pages (e.g. '1 .. 5 6 7 [8] 9 10 11 .. 50').
+
+        tmpl_format:
+            Format string that defines how the pager is rendered. The string
+            can contain the following $-tokens that are substituted by the
+            string.Template module:
+
+            - $first_page: number of first reachable page
+            - $last_page: number of last reachable page
+            - $page: number of currently selected page
+            - $page_count: number of reachable pages
+            - $items_per_page: maximal number of items per page
+            - $first_item: index of first item on the current page
+            - $last_item: index of last item on the current page
+            - $item_count: total number of items
+            - $link_first: link to first page (unless this is first page)
+            - $link_last: link to last page (unless this is last page)
+            - $link_previous: link to previous page (unless this is first page)
+            - $link_next: link to next page (unless this is last page)
+
+            To render a range of pages the token '~3~' can be used. The
+            number sets the radius of pages around the current page.
+            Example for a range with radius 3:
+
+            '1 .. 5 6 7 [8] 9 10 11 .. 50'
+
+            Default: '~2~'
+
+        url
+            The URL that page links will point to. Make sure it contains the string
+            $page which will be replaced by the actual page number.
+            Must be given unless a url_maker is specified to __init__, in which
+            case this parameter is ignored.
+
+        symbol_first
+            String to be displayed as the text for the $link_first link above.
+
+            Default: '&lt;&lt;' (<<)
+
+        symbol_last
+            String to be displayed as the text for the $link_last link above.
+
+            Default: '&gt;&gt;' (>>)
+
+        symbol_previous
+            String to be displayed as the text for the $link_previous link above.
+
+            Default: '&lt;' (<)
+
+        symbol_next
+            String to be displayed as the text for the $link_next link above.
+
+            Default: '&gt;' (>)
+
+        separator:
+            String that is used to separate page links/numbers in the above range of pages.
+
+            Default: ' '
+
+        show_if_single_page:
+            if True the navigator will be shown even if there is only one page.
+
+            Default: False
+
+        link_attr (optional)
+            A dictionary of attributes that get added to A-HREF links pointing to other pages. Can
+            be used to define a CSS style or class to customize the look of links.
+
+            Example: { 'style':'border: 1px solid green' }
+            Example: { 'class':'pager_link' }
+
+        curpage_attr (optional)
+            A dictionary of attributes that get added to the current page number in the pager (which
+            is obviously not a link). If this dictionary is not empty then the elements will be
+            wrapped in a SPAN tag with the given attributes.
+
+            Example: { 'style':'border: 3px solid blue' }
+            Example: { 'class':'pager_curpage' }
+
+        dotdot_attr (optional)
+            A dictionary of attributes that get added to the '..' string in the pager (which is
+            obviously not a link). If this dictionary is not empty then the elements will be wrapped
+            in a SPAN tag with the given attributes.
+
+            Example: { 'style':'color: #808080' }
+            Example: { 'class':'pager_dotdot' }
+
+        link_tag (optional)
+            A callable that accepts single argument `page` (page link information)
+            and generates string with html that represents the link for specific page.
+            Page objects are supplied from `link_map()` so the keys are the same.
+
+
+        """
+        link_attr = link_attr or {}
+        curpage_attr = curpage_attr or {}
+        dotdot_attr = dotdot_attr or {}
+        self.curpage_attr = curpage_attr
+        self.separator = separator
+        self.link_attr = link_attr
+        self.dotdot_attr = dotdot_attr
+        self.url = url
+        self.link_tag = link_tag or self.default_link_tag
+
+        # Don't show navigator if there is no more than one page
+        if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):
+            return ""
+
+        regex_res = re.search(r"~(\d+)~", tmpl_format)
+        if regex_res:
+            radius = regex_res.group(1)
+        else:
+            radius = 2
+
+        self.radius = int(radius)
+        link_map = self.link_map(
+            tmpl_format=tmpl_format,
+            url=url,
+            show_if_single_page=show_if_single_page,
+            separator=separator,
+            symbol_first=symbol_first,
+            symbol_last=symbol_last,
+            symbol_previous=symbol_previous,
+            symbol_next=symbol_next,
+            link_attr=link_attr,
+            curpage_attr=curpage_attr,
+            dotdot_attr=dotdot_attr,
+            link_tag=link_tag,
+        )
+        links_markup = self._range(link_map, self.radius)
+
+        # Replace ~...~ in token tmpl_format by range of pages
+        result = re.sub(r"~(\d+)~", links_markup, tmpl_format)
+
+        link_first = (
+            self.page > self.first_page and self.link_tag(link_map["first_page"]) or ""
+        )
+        link_last = (
+            self.page < self.last_page and self.link_tag(link_map["last_page"]) or ""
+        )
+        link_previous = (
+            self.previous_page and self.link_tag(link_map["previous_page"]) or ""
+        )
+        link_next = self.next_page and self.link_tag(link_map["next_page"]) or ""
+        # Interpolate '$' variables
+        result = Template(result).safe_substitute(
+            {
+                "first_page": self.first_page,
+                "last_page": self.last_page,
+                "page": self.page,
+                "page_count": self.page_count,
+                "items_per_page": self.items_per_page,
+                "first_item": self.first_item,
+                "last_item": self.last_item,
+                "item_count": self.item_count,
+                "link_first": link_first,
+                "link_last": link_last,
+                "link_previous": link_previous,
+                "link_next": link_next,
+            }
+        )
+
+        return result
+
+    def _get_edges(self, cur_page, max_page, items):
+        cur_page = int(cur_page)
+        edge = (items / 2) + 1
+        if cur_page <= edge:
+            radius = max(items / 2, items - cur_page)
+        elif (max_page - cur_page) < edge:
+            radius = (items - 1) - (max_page - cur_page)
+        else:
+            radius = (items / 2) - 1
+
+        left = max(1, (cur_page - radius))
+        right = min(max_page, cur_page + radius)
+        return left, right
+
+    def link_map(
+            self,
+            tmpl_format="~2~",
+            url=None,
+            show_if_single_page=False,
+            separator=" ",
+            symbol_first="&lt;&lt;",
+            symbol_last="&gt;&gt;",
+            symbol_previous="&lt;",
+            symbol_next="&gt;",
+            link_attr=None,
+            curpage_attr=None,
+            dotdot_attr=None,
+            link_tag=None
+    ):
+        """ Return map with links to other pages if default pager() function is not suitable solution.
+        tmpl_format:
+            Format string that defines how the pager would be normally rendered rendered. Uses same arguments as pager()
+            method, but returns a simple dictionary in form of:
+            {'current_page': {'attrs': {},
+                                     'href': 'http://example.org/foo/page=1',
+                                     'value': 1},
+                    'first_page': {'attrs': {},
+                                   'href': 'http://example.org/foo/page=1',
+                                   'type': 'first_page',
+                                   'value': 1},
+                    'last_page': {'attrs': {},
+                                  'href': 'http://example.org/foo/page=8',
+                                  'type': 'last_page',
+                                  'value': 8},
+                    'next_page': {'attrs': {}, 'href': 'HREF', 'type': 'next_page', 'value': 2},
+                    'previous_page': None,
+                    'range_pages': [{'attrs': {},
+                                     'href': 'http://example.org/foo/page=1',
+                                     'type': 'current_page',
+                                     'value': 1},
+                                     ....
+                                    {'attrs': {}, 'href': '', 'type': 'span', 'value': '..'}]}
+
+
+            The string can contain the following $-tokens that are substituted by the
+            string.Template module:
+
+            - $first_page: number of first reachable page
+            - $last_page: number of last reachable page
+            - $page: number of currently selected page
+            - $page_count: number of reachable pages
+            - $items_per_page: maximal number of items per page
+            - $first_item: index of first item on the current page
+            - $last_item: index of last item on the current page
+            - $item_count: total number of items
+            - $link_first: link to first page (unless this is first page)
+            - $link_last: link to last page (unless this is last page)
+            - $link_previous: link to previous page (unless this is first page)
+            - $link_next: link to next page (unless this is last page)
+
+            To render a range of pages the token '~3~' can be used. The
+            number sets the radius of pages around the current page.
+            Example for a range with radius 3:
+
+            '1 .. 5 6 7 [8] 9 10 11 .. 50'
+
+            Default: '~2~'
+
+        url
+            The URL that page links will point to. Make sure it contains the string
+            $page which will be replaced by the actual page number.
+            Must be given unless a url_maker is specified to __init__, in which
+            case this parameter is ignored.
+
+        symbol_first
+            String to be displayed as the text for the $link_first link above.
+
+            Default: '&lt;&lt;' (<<)
+
+        symbol_last
+            String to be displayed as the text for the $link_last link above.
+
+            Default: '&gt;&gt;' (>>)
+
+        symbol_previous
+            String to be displayed as the text for the $link_previous link above.
+
+            Default: '&lt;' (<)
+
+        symbol_next
+            String to be displayed as the text for the $link_next link above.
+
+            Default: '&gt;' (>)
+
+        separator:
+            String that is used to separate page links/numbers in the above range of pages.
+
+            Default: ' '
+
+        show_if_single_page:
+            if True the navigator will be shown even if there is only one page.
+
+            Default: False
+
+        link_attr (optional)
+            A dictionary of attributes that get added to A-HREF links pointing to other pages. Can
+            be used to define a CSS style or class to customize the look of links.
+
+            Example: { 'style':'border: 1px solid green' }
+            Example: { 'class':'pager_link' }
+
+        curpage_attr (optional)
+            A dictionary of attributes that get added to the current page number in the pager (which
+            is obviously not a link). If this dictionary is not empty then the elements will be
+            wrapped in a SPAN tag with the given attributes.
+
+            Example: { 'style':'border: 3px solid blue' }
+            Example: { 'class':'pager_curpage' }
+
+        dotdot_attr (optional)
+            A dictionary of attributes that get added to the '..' string in the pager (which is
+            obviously not a link). If this dictionary is not empty then the elements will be wrapped
+            in a SPAN tag with the given attributes.
+
+            Example: { 'style':'color: #808080' }
+            Example: { 'class':'pager_dotdot' }
+        """
+        link_attr = link_attr or {}
+        curpage_attr = curpage_attr or {}
+        dotdot_attr = dotdot_attr or {}
+        self.curpage_attr = curpage_attr
+        self.separator = separator
+        self.link_attr = link_attr
+        self.dotdot_attr = dotdot_attr
+        self.url = url
+
+        regex_res = re.search(r"~(\d+)~", tmpl_format)
+        if regex_res:
+            radius = regex_res.group(1)
+        else:
+            radius = 2
+
+        self.radius = int(radius)
+
+        # Compute the first and last page number within the radius
+        # e.g. '1 .. 5 6 [7] 8 9 .. 12'
+        # -> leftmost_page  = 5
+        # -> rightmost_page = 9
+        leftmost_page, rightmost_page = self._get_edges(
+            self.page, self.last_page, (self.radius * 2) + 1)
+
+        nav_items = {
+            "first_page": None,
+            "last_page": None,
+            "previous_page": None,
+            "next_page": None,
+            "current_page": None,
+            "radius": self.radius,
+            "range_pages": [],
+        }
+
+        if leftmost_page is None or rightmost_page is None:
+            return nav_items
+
+        nav_items["first_page"] = {
+            "type": "first_page",
+            "value": unicode(symbol_first),
+            "attrs": self.link_attr,
+            "number": self.first_page,
+            "href": self.url_maker(self.first_page),
+        }
+
+        # Insert dots if there are pages between the first page
+        # and the currently displayed page range
+        if leftmost_page - self.first_page > 1:
+            # Wrap in a SPAN tag if dotdot_attr is set
+            nav_items["range_pages"].append(
+                {
+                    "type": "span",
+                    "value": "..",
+                    "attrs": self.dotdot_attr,
+                    "href": "",
+                    "number": None,
+                }
+            )
+
+        for this_page in range(leftmost_page, rightmost_page + 1):
+            # Highlight the current page number and do not use a link
+            if this_page == self.page:
+                # Wrap in a SPAN tag if curpage_attr is set
+                nav_items["range_pages"].append(
+                    {
+                        "type": "current_page",
+                        "value": unicode(this_page),
+                        "number": this_page,
+                        "attrs": self.curpage_attr,
+                        "href": self.url_maker(this_page),
+                    }
+                )
+                nav_items["current_page"] = {
+                    "value": this_page,
+                    "attrs": self.curpage_attr,
+                    "type": "current_page",
+                    "href": self.url_maker(this_page),
+                }
+            # Otherwise create just a link to that page
+            else:
+                nav_items["range_pages"].append(
+                    {
+                        "type": "page",
+                        "value": unicode(this_page),
+                        "number": this_page,
+                        "attrs": self.link_attr,
+                        "href": self.url_maker(this_page),
+                    }
+                )
+
+        # Insert dots if there are pages between the displayed
+        # page numbers and the end of the page range
+        if self.last_page - rightmost_page > 1:
+            # Wrap in a SPAN tag if dotdot_attr is set
+            nav_items["range_pages"].append(
+                {
+                    "type": "span",
+                    "value": "..",
+                    "attrs": self.dotdot_attr,
+                    "href": "",
+                    "number": None,
+                }
+            )
+
+        # Create a link to the very last page (unless we are on the last
+        # page or there would be no need to insert '..' spacers)
+        nav_items["last_page"] = {
+            "type": "last_page",
+            "value": unicode(symbol_last),
+            "attrs": self.link_attr,
+            "href": self.url_maker(self.last_page),
+            "number": self.last_page,
+        }
+
+        nav_items["previous_page"] = {
+            "type": "previous_page",
+            "value": unicode(symbol_previous),
+            "attrs": self.link_attr,
+            "number": self.previous_page or self.first_page,
+            "href": self.url_maker(self.previous_page or self.first_page),
+        }
+
+        nav_items["next_page"] = {
+            "type": "next_page",
+            "value": unicode(symbol_next),
+            "attrs": self.link_attr,
+            "number": self.next_page or self.last_page,
+            "href": self.url_maker(self.next_page or self.last_page),
+        }
+
+        return nav_items
+
+    def _range(self, link_map, radius):
+        """
+        Return range of linked pages to substitute placeholder in pattern
+        """
+        # Compute the first and last page number within the radius
+        # e.g. '1 .. 5 6 [7] 8 9 .. 12'
+        # -> leftmost_page  = 5
+        # -> rightmost_page = 9
+        leftmost_page, rightmost_page = self._get_edges(
+            self.page, self.last_page, (radius * 2) + 1)
+
+        nav_items = []
+        # Create a link to the first page (unless we are on the first page
+        # or there would be no need to insert '..' spacers)
+        if self.first_page and self.page != self.first_page and self.first_page < leftmost_page:
+            page = link_map["first_page"].copy()
+            page["value"] = unicode(page["number"])
+            nav_items.append(self.link_tag(page))
+
+        for item in link_map["range_pages"]:
+            nav_items.append(self.link_tag(item))
+
+        # Create a link to the very last page (unless we are on the last
+        # page or there would be no need to insert '..' spacers)
+        if self.last_page and self.page != self.last_page and rightmost_page < self.last_page:
+            page = link_map["last_page"].copy()
+            page["value"] = unicode(page["number"])
+            nav_items.append(self.link_tag(page))
+
+        return self.separator.join(nav_items)
+
+    def _default_url_maker(self, page_number):
+        if self.url is None:
+            raise Exception(
+                "You need to specify a 'url' parameter containing a '$page' placeholder."
+            )
+
+        if "$page" not in self.url:
+            raise Exception("The 'url' parameter must contain a '$page' placeholder.")
+
+        return self.url.replace("$page", unicode(page_number))
+
+    @staticmethod
+    def default_link_tag(item):
+        """
+        Create an A-HREF tag that points to another page.
+        """
+        text = item["value"]
+        target_url = item["href"]
+
+        if not item["href"] or item["type"] in ("span", "current_page"):
+            if item["attrs"]:
+                text = make_html_tag("span", **item["attrs"]) + text + "</span>"
+            return text
+
+        return make_html_tag("a", text=text, href=target_url, **item["attrs"])
+
+# Below is RhodeCode custom code
+
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -17,149 +894,163 b''
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
-import re
+
+
+PAGE_FORMAT = '$link_previous ~3~ $link_next'
+
+
+class SqlalchemyOrmWrapper(object):
+    """Wrapper class to access elements of a collection."""
 
-from webhelpers.paginate import Page as _Page
-from webhelpers.paginate import PageURL
-from webhelpers2.html import literal, HTML
+    def __init__(self, pager, collection):
+        self.pager = pager
+        self.collection = collection
+
+    def __getitem__(self, range):
+        # Return a range of objects of an sqlalchemy.orm.query.Query object
+        return self.collection[range]
+
+    def __len__(self):
+        # Count the number of objects in an sqlalchemy.orm.query.Query object
+        return self.collection.count()
 
 
-class Page(_Page):
+class CustomPager(_Page):
+
+    @staticmethod
+    def disabled_link_tag(item):
+        """
+        Create an A-HREF tag that is disabled
+        """
+        text = item['value']
+        attrs = item['attrs'].copy()
+        attrs['class'] = 'disabled ' + attrs['class']
+
+        return make_html_tag('a', text=text, **attrs)
+
+    def render(self):
+        # Don't show navigator if there is no more than one page
+        if self.page_count == 0:
+            return ""
+
+        self.link_tag = self.default_link_tag
+
+        link_map = self.link_map(
+            tmpl_format=PAGE_FORMAT, url=None,
+            show_if_single_page=False, separator=' ',
+            symbol_first='<<', symbol_last='>>',
+            symbol_previous='<', symbol_next='>',
+            link_attr={'class': 'pager_link'},
+            curpage_attr={'class': 'pager_curpage'},
+            dotdot_attr={'class': 'pager_dotdot'})
+
+        links_markup = self._range(link_map, self.radius)
+
+        link_first = (
+            self.page > self.first_page and self.link_tag(link_map['first_page']) or ''
+        )
+        link_last = (
+            self.page < self.last_page and self.link_tag(link_map['last_page']) or ''
+        )
+
+        link_previous = (
+            self.previous_page and self.link_tag(link_map['previous_page'])
+            or self.disabled_link_tag(link_map['previous_page'])
+        )
+        link_next = (
+            self.next_page and self.link_tag(link_map['next_page'])
+            or self.disabled_link_tag(link_map['next_page'])
+        )
+
+        # Interpolate '$' variables
+        # Replace ~...~ in token tmpl_format by range of pages
+        result = re.sub(r"~(\d+)~", links_markup, PAGE_FORMAT)
+        result = Template(result).safe_substitute(
+            {
+                "links": links_markup,
+                "first_page": self.first_page,
+                "last_page": self.last_page,
+                "page": self.page,
+                "page_count": self.page_count,
+                "items_per_page": self.items_per_page,
+                "first_item": self.first_item,
+                "last_item": self.last_item,
+                "item_count": self.item_count,
+                "link_first": link_first,
+                "link_last": link_last,
+                "link_previous": link_previous,
+                "link_next": link_next,
+            }
+        )
+
+        return literal(result)
+
+
+class Page(CustomPager):
     """
     Custom pager to match rendering style with paginator
     """
 
-    def _get_pos(self, cur_page, max_page, items):
-        edge = (items / 2) + 1
-        if (cur_page <= edge):
-            radius = max(items / 2, items - cur_page)
-        elif (max_page - cur_page) < edge:
-            radius = (items - 1) - (max_page - cur_page)
-        else:
-            radius = items / 2
-
-        left = max(1, (cur_page - (radius)))
-        right = min(max_page, cur_page + (radius))
-        return left, cur_page, right
-
-    def _range(self, regexp_match):
+    def __init__(self, collection, page=1, items_per_page=20, item_count=None,
+                 url_maker=None, **kwargs):
+        """
+        Special type of pager. We intercept collection to wrap it in our custom
+        logic instead of using wrapper_class
         """
-        Return range of linked pages (e.g. '1 2 [3] 4 5 6 7 8').
-
-        Arguments:
 
-        regexp_match
-            A "re" (regular expressions) match object containing the
-            radius of linked pages around the current page in
-            regexp_match.group(1) as a string
+        super(Page, self).__init__(collection=collection, page=page,
+                                   items_per_page=items_per_page, item_count=item_count,
+                                   wrapper_class=None, url_maker=url_maker, **kwargs)
 
-        This function is supposed to be called as a callable in
-        re.sub.
-
-        """
-        radius = int(regexp_match.group(1))
 
-        # Compute the first and last page number within the radius
-        # e.g. '1 .. 5 6 [7] 8 9 .. 12'
-        # -> leftmost_page  = 5
-        # -> rightmost_page = 9
-        leftmost_page, _cur, rightmost_page = self._get_pos(self.page,
-                                                            self.last_page,
-                                                            (radius * 2) + 1)
-        nav_items = []
-
-        # Create a link to the first page (unless we are on the first page
-        # or there would be no need to insert '..' spacers)
-        if self.page != self.first_page and self.first_page < leftmost_page:
-            nav_items.append(self._pagerlink(self.first_page, self.first_page))
+class SqlPage(CustomPager):
+    """
+    Custom pager to match rendering style with paginator
+    """
 
-        # Insert dots if there are pages between the first page
-        # and the currently displayed page range
-        if leftmost_page - self.first_page > 1:
-            # Wrap in a SPAN tag if nolink_attr is set
-            text = '..'
-            if self.dotdot_attr:
-                text = HTML.span(c=text, **self.dotdot_attr)
-            nav_items.append(text)
+    def __init__(self, collection, page=1, items_per_page=20, item_count=None,
+                 url_maker=None, **kwargs):
+        """
+        Special type of pager. We intercept collection to wrap it in our custom
+        logic instead of using wrapper_class
+        """
+        collection = SqlalchemyOrmWrapper(self, collection)
 
-        for thispage in xrange(leftmost_page, rightmost_page + 1):
-            # Hilight the current page number and do not use a link
-            if thispage == self.page:
-                text = '%s' % (thispage,)
-                # Wrap in a SPAN tag if nolink_attr is set
-                if self.curpage_attr:
-                    text = HTML.span(c=text, **self.curpage_attr)
-                nav_items.append(text)
-            # Otherwise create just a link to that page
-            else:
-                text = '%s' % (thispage,)
-                nav_items.append(self._pagerlink(thispage, text))
+        super(SqlPage, self).__init__(collection=collection, page=page,
+                                      items_per_page=items_per_page, item_count=item_count,
+                                      wrapper_class=None, url_maker=url_maker, **kwargs)
+
 
-        # Insert dots if there are pages between the displayed
-        # page numbers and the end of the page range
-        if self.last_page - rightmost_page > 1:
-            text = '..'
-            # Wrap in a SPAN tag if nolink_attr is set
-            if self.dotdot_attr:
-                text = HTML.span(c=text, **self.dotdot_attr)
-            nav_items.append(text)
+class RepoCommitsWrapper(object):
+    """Wrapper class to access elements of a collection."""
 
-        # Create a link to the very last page (unless we are on the last
-        # page or there would be no need to insert '..' spacers)
-        if self.page != self.last_page and rightmost_page < self.last_page:
-            nav_items.append(self._pagerlink(self.last_page, self.last_page))
+    def __init__(self, pager, collection):
+        self.pager = pager
+        self.collection = collection
 
-        ## prerender links
-        #_page_link = url.current()
-        #nav_items.append(literal('<link rel="prerender" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
-        #nav_items.append(literal('<link rel="prefetch" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
-        return self.separator.join(nav_items)
+    def __getitem__(self, range):
+        cur_page = self.pager.page
+        items_per_page = self.pager.items_per_page
+        first_item = max(0, (len(self.collection) - (cur_page * items_per_page)))
+        last_item = ((len(self.collection) - 1) - items_per_page * (cur_page - 1))
+        return reversed(list(self.collection[first_item:last_item + 1]))
 
-    def pager(self, format='~2~', page_param='page', partial_param='partial',
-        show_if_single_page=False, separator=' ', onclick=None,
-        symbol_first='<<', symbol_last='>>',
-        symbol_previous='<', symbol_next='>',
-        link_attr={'class': 'pager_link', 'rel': 'prerender'},
-        curpage_attr={'class': 'pager_curpage'},
-        dotdot_attr={'class': 'pager_dotdot'}, **kwargs):
+    def __len__(self):
+        return len(self.collection)
 
-        self.curpage_attr = curpage_attr
-        self.separator = separator
-        self.pager_kwargs = kwargs
-        self.page_param = page_param
-        self.partial_param = partial_param
-        self.onclick = onclick
-        self.link_attr = link_attr
-        self.dotdot_attr = dotdot_attr
 
-        # Don't show navigator if there is no more than one page
-        if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):
-            return ''
-
-        from string import Template
-        # Replace ~...~ in token format by range of pages
-        result = re.sub(r'~(\d+)~', self._range, format)
+class RepoPage(CustomPager):
+    """
+    Create a "RepoPage" instance. special pager for paging repository
+    """
 
-        # Interpolate '%' variables
-        result = Template(result).safe_substitute({
-            'first_page': self.first_page,
-            'last_page': self.last_page,
-            'page': self.page,
-            'page_count': self.page_count,
-            'items_per_page': self.items_per_page,
-            'first_item': self.first_item,
-            'last_item': self.last_item,
-            'item_count': self.item_count,
-            'link_first': self.page > self.first_page and \
-                    self._pagerlink(self.first_page, symbol_first) or '',
-            'link_last': self.page < self.last_page and \
-                    self._pagerlink(self.last_page, symbol_last) or '',
-            'link_previous': self.previous_page and \
-                    self._pagerlink(self.previous_page, symbol_previous) \
-                    or HTML.span(symbol_previous, class_="pg-previous disabled"),
-            'link_next': self.next_page and \
-                    self._pagerlink(self.next_page, symbol_next) \
-                    or HTML.span(symbol_next, class_="pg-next disabled")
-        })
-
-        return literal(result)
+    def __init__(self, collection, page=1, items_per_page=20, item_count=None,
+                 url_maker=None, **kwargs):
+        """
+        Special type of pager. We intercept collection to wrap it in our custom
+        logic instead of using wrapper_class
+        """
+        collection = RepoCommitsWrapper(self, collection)
+        super(RepoPage, self).__init__(collection=collection, page=page,
+                                       items_per_page=items_per_page, item_count=item_count,
+                                       wrapper_class=None, url_maker=url_maker, **kwargs)

rhodecode/public/css/navigation.less

@@ -625,8 +625,9 b' ul#context-pages {'
     top: 95px;
 }
 
-.dataTables_paginate, .pagination-wh {
-    text-align: left;
+.dataTables_paginate,
+.pagination-wh {
+    text-align: center;
     display: inline-block;
     border-left: 1px solid @grey5;
     float: none;
@@ -638,10 +639,15 b' ul#context-pages {'
         display: inline-block;
         padding: @menupadding/4 @menupadding;
         border: 1px solid @grey5;
-        border-left: 0;
+        margin-left: -1px;
         color: @grey2;
         cursor: pointer;
         float: left;
+        font-weight: 600;
+        white-space: nowrap;
+        vertical-align: middle;
+        user-select: none;
+        min-width: 15px;
 
         &:hover {
             color: @rcdarkblue;

rhodecode/templates/admin/admin_log_base.mako

@@ -62,7 +62,7 b''
 </table>
 
 <div class="pagination-wh pagination-left">
-${c.audit_logs.pager('$link_previous ~2~ $link_next')}
+${c.audit_logs.render()}
 </div>
 %else:
     ${_('No actions yet')}

rhodecode/templates/admin/integrations/list.mako

@@ -188,7 +188,7 b''
     </table>
     <div class="integrations-paginator">
       <div class="pagination-wh pagination-left">
-      ${c.integrations_list.pager('$link_previous ~2~ $link_next')}
+      ${c.integrations_list.render()}
       </div>
     </div>
   </div>

rhodecode/templates/admin/notifications/notifications_data.mako

@@ -34,7 +34,7 b''
 
         <div class="notification-paginator">
             <div class="pagination-wh pagination-left">
-                ${c.notifications.pager('$link_previous ~2~ $link_next')}
+                ${c.notifications.render()}
             </div>
         </div>
 

rhodecode/templates/commits/changelog.mako

@@ -130,7 +130,7 b''
               </div>
             </div>
             <div class="pagination-wh pagination-left">
-            ${c.pagination.pager('$link_previous ~2~ $link_next')}
+            ${c.pagination.render()}
             </div>
             <div id="commit-counter" data-total=${c.total_cs} class="pull-right">
                 ${_ungettext('showing %d out of %d commit', 'showing %d out of %d commits', c.showing_commits) % (c.showing_commits, c.total_cs)}

rhodecode/templates/journal/journal.mako

@@ -37,7 +37,9 b''
          <span><a id="refresh" href="${h.route_path('journal')}"><i class="icon-refresh"></i></a></span>
        </li>
        <li>
-         <span><a href="${h.route_path('journal_atom', _query=dict(auth_token=c.rhodecode_user.feed_token))}"><i class="icon-rss-sign"></i></a></span>
+         <span>
+             <a href="${h.route_path('journal_atom', _query=dict(auth_token=c.rhodecode_user.feed_token))}" title="RSS Feed" class="btn btn-sm"><i class="icon-rss-sign"></i>RSS</a>
+         </span>
        </li>
      </ul>
     </div>
@@ -45,14 +47,6 b''
 </div>
 
 <script type="text/javascript">
-
-$('#j_filter').autoGrowInput();
-$(document).on('pjax:success',function(){
-  show_more_event();
-});
-$(document).pjax(
-    '#refresh', '#journal',
-    {url: "${request.current_route_path(_query=dict(filter=c.search_term))}", push: false});
-
+    $('#j_filter').autoGrowInput();
 </script>
 </%def>

rhodecode/templates/journal/journal_data.mako

@@ -36,17 +36,10 b''
         %endfor
     %endfor
 
-  <div class="pagination-wh pagination-left" >
-  ${c.journal_pager.pager('$link_previous ~2~ $link_next')}
+  <div class="pagination-wh pagination-left">
+  ${c.journal_pager.render()}
   </div>
-    <script type="text/javascript">
-      $(document).pjax('#journal .pager_link','#journal');
-      $(document).on('pjax:success',function(){
-        show_more_event();
-        timeagoActivate();
-        tooltipActivate();
-      });
-    </script>
+
 %else:
   <div>
       ${_('No entries yet')}

rhodecode/templates/search/search.mako

@@ -65,11 +65,11 b''
 
     <%
     if c.sort.startswith('asc:'):
-        return c.url_generator(sort='desc:{}'.format(field_name))
+        return h.current_route_path(request, sort='desc:{}'.format(field_name))
     elif c.sort.startswith('desc:'):
-        return c.url_generator(sort='asc:{}'.format(field_name))
+        return h.current_route_path(request, sort='asc:{}'.format(field_name))
 
-    return c.url_generator(sort='asc:{}'.format(field_name))
+    return h.current_route_path(request, sort='asc:{}'.format(field_name))
     %>
 </%def>
 

rhodecode/templates/search/search_commit.mako

@@ -63,7 +63,7 b''
 
 %if c.cur_query:
 <div class="pagination-wh pagination-left">
-    ${c.formatted_results.pager('$link_previous ~2~ $link_next')}
+    ${c.formatted_results.render()}
 </div>
 %endif
 

rhodecode/templates/search/search_content.mako

@@ -145,7 +145,7 b''
 </div>
 %if c.cur_query and c.formatted_results:
 <div class="pagination-wh pagination-left" >
-    ${c.formatted_results.pager('$link_previous ~2~ $link_next')}
+    ${c.formatted_results.render()}
 </div>
 %endif
 

rhodecode/templates/search/search_path.mako

@@ -46,7 +46,7 b''
 
 %if c.cur_query:
 <div class="pagination-wh pagination-left">
-    ${c.formatted_results.pager('$link_previous ~2~ $link_next')}
+    ${c.formatted_results.render()}
 </div>
 %endif
 

rhodecode/templates/summary/summary_commits.mako

@@ -107,7 +107,7 b''
 </script>
 
 <div class="pagination-wh pagination-left">
-${c.repo_commits.pager('$link_previous ~2~ $link_next')}
+${c.repo_commits.render()}
 </div>
 %else: