if not isinstance(owner, Optional):

                # forbid setting owner for non-admins

                raise JSONRPCError(

                    'Only Kallithea admin can specify `owner` param'

                )

        if isinstance(owner, Optional):

            owner = request.authuser.user_id

        owner = get_user_or_error(owner)

        if RepoModel().get_by_repo_name(repo_name):

            raise JSONRPCError("repo `%s` already exist" % repo_name)

        defs = Setting.get_default_repo_settings(strip_prefix=True)

        if isinstance(private, Optional):

            private = defs.get('repo_private') or Optional.extract(private)

        if isinstance(repo_type, Optional):

            repo_type = defs.get('repo_type')

        if isinstance(enable_statistics, Optional):

            enable_statistics = defs.get('repo_enable_statistics')

        if isinstance(enable_downloads, Optional):

            enable_downloads = defs.get('repo_enable_downloads')

        clone_uri = Optional.extract(clone_uri)

        description = Optional.extract(description)

        landing_rev = Optional.extract(landing_rev)

        copy_permissions = Optional.extract(copy_permissions)

        try:

            repo_name_parts = repo_name.split('/')

            repo_group = None

            if len(repo_name_parts) > 1:

                group_name = '/'.join(repo_name_parts[:-1])

                repo_group = RepoGroup.get_by_group_name(group_name)

                if repo_group is None:

                    raise JSONRPCError("repo group `%s` not found" % group_name)

            data = dict(

                repo_name=repo_name_parts[-1],

                repo_name_full=repo_name,

                repo_type=repo_type,

                repo_description=description,

                owner=owner,

                repo_private=private,

                clone_uri=clone_uri,

                repo_group=repo_group,

                repo_landing_rev=landing_rev,

                enable_statistics=enable_statistics,

                enable_downloads=enable_downloads,

                repo_copy_permissions=copy_permissions,

            )

            task = RepoModel().create(form_data=data, cur_user=owner)

            task_id = task.task_id

            # no commit, it's done in RepoModel, or async via celery

            return dict(

                msg="Created new repository `%s`" % (repo_name,),

                success=True,  # cannot return the repo data here since fork

                               # can be done async

                task=task_id

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to create repository `%s`' % (repo_name,))

    # permission check inside

    def update_repo(self, repoid, name=Optional(None),

                    owner=Optional(OAttr('apiuser')),

                    group=Optional(None),

                    description=Optional(''), private=Optional(False),

                    clone_uri=Optional(None), landing_rev=Optional('rev:tip'),

                    enable_statistics=Optional(False),

                    enable_downloads=Optional(False)):

        """

        Updates repo

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param name:

        :param owner:

        :param group:

        :param description:

        :param private:

        :param clone_uri:

        :param landing_rev:

        :param enable_statistics:

        :param enable_downloads:

        """

        repo = get_repo_or_error(repoid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoPermissionLevel('admin')(repo.repo_name):

                raise JSONRPCError('repository `%s` does not exist' % (repoid,))

            if (name != repo.repo_name and

                not HasPermissionAny('hg.create.repository')()

                raise JSONRPCError('no permission to create (or move) repositories')

            if not isinstance(owner, Optional):

                # forbid setting owner for non-admins

                raise JSONRPCError(

                    'Only Kallithea admin can specify `owner` param'

                )

        updates = {}

        repo_group = group

        if not isinstance(repo_group, Optional):

            repo_group = get_repo_group_or_error(repo_group)

            repo_group = repo_group.group_id

        try:

            store_update(updates, name, 'repo_name')

            store_update(updates, repo_group, 'repo_group')

            store_update(updates, owner, 'owner')

            store_update(updates, description, 'repo_description')

            store_update(updates, private, 'repo_private')

            store_update(updates, clone_uri, 'clone_uri')

            store_update(updates, landing_rev, 'repo_landing_rev')

            store_update(updates, enable_statistics, 'repo_enable_statistics')

            store_update(updates, enable_downloads, 'repo_enable_downloads')

            RepoModel().update(repo, **updates)

            Session().commit()

            return dict(

                msg='updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),

                repository=repo.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to update repo `%s`' % repoid)

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    def fork_repo(self, repoid, fork_name,

                  owner=Optional(OAttr('apiuser')),

                  description=Optional(''), copy_permissions=Optional(False),

                  private=Optional(False), landing_rev=Optional('rev:tip')):

        """

        Creates a fork of given repo. In case of using celery this will

        immediately return success message, while fork is going to be created

        asynchronous. This command can be executed only using api_key belonging to

        user with admin rights or regular user that have fork permission, and at least

        read access to forking repository. Regular users cannot specify owner parameter.

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param fork_name:

        :param owner:

        :param description:

        :param copy_permissions:

        :param private:

        :param landing_rev:

        INPUT::

            id : <id_for_response>

            api_key : "<api_key>"

            args:     {

                        "repoid" :          "<reponame or repo_id>",

                        "fork_name":        "<forkname>",

                        "owner":            "<username or user_id = Optional(=apiuser)>",

                        "description":      "<description>",

                        "copy_permissions": "<bool>",

                        "private":          "<bool>",

                        "landing_rev":      "<landing_rev>"

                      }

        OUTPUT::

            id : <id_given_in_input>

            result: {

                      "msg": "Created fork of `<reponame>` as `<forkname>`",

                      "success": true,

                      "task": "<celery task id or None if done sync>"

                    }

            error:  null

        """

        repo = get_repo_or_error(repoid)

        repo_name = repo.repo_name

        _repo = RepoModel().get_by_repo_name(fork_name)

        if _repo:

            type_ = 'fork' if _repo.fork else 'repo'

            raise JSONRPCError("%s `%s` already exist" % (type_, fork_name))

        if HasPermissionAny('hg.admin')():

            pass

        elif HasRepoPermissionLevel('read')(repo.repo_name):

            if not isinstance(owner, Optional):

                # forbid setting owner for non-admins

                raise JSONRPCError(

                    'Only Kallithea admin can specify `owner` param'

                )

        _ln_ctx = filter(lambda k: k.startswith('C'), GET)

        ln_ctx = GET.get(_ln_ctx[0]) if _ln_ctx else ln_ctx_global

        if ln_ctx:

            ln_ctx = [ln_ctx]

    if ln_ctx:

        retval = ln_ctx[0].split(':')[-1]

    else:

        retval = ln_ctx_global

    try:

        return int(retval)

    except Exception:

        return 3

def _context_url(GET, fileid=None):

    """

    Generates url for context lines

    :param fileid:

    """

    fileid = str(fileid) if fileid else None

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2

    params = defaultdict(list)

    _update_with_GET(params, GET)

    # global option

    if fileid is None:

        if ln_ctx > 0:

            params['context'] += [ln_ctx]

        if ig_ws:

            ig_ws_key = 'ignorews'

            ig_ws_val = 1

    # per file option

    else:

        params[fileid] += ['C:%s' % ln_ctx]

        ig_ws_key = fileid

        ig_ws_val = 'WS:%s' % 1

    if ig_ws:

        params[ig_ws_key] += [ig_ws_val]

    lbl = _('Increase diff context to %(num)s lines') % {'num': ln_ctx}

    params['anchor'] = fileid

    icon = h.literal('<i class="icon-sort"></i>')

    return h.link_to(icon, h.url.current(**params), title=lbl, **{'data-toggle': 'tooltip'})

def create_cs_pr_comment(repo_name, revision=None, pull_request=None, allowed_to_change_status=True):

    """

    Add a comment to the specified changeset or pull request, using POST values

    from the request.

    Comments can be inline (when a file path and line number is specified in

    POST) or general comments.

    A comment can be accompanied by a review status change (accepted, rejected,

    etc.). Pull requests can be closed or deleted.

    Parameter 'allowed_to_change_status' is used for both status changes and

    closing of pull requests. For deleting of pull requests, more specific

    checks are done.

    """

    assert request.environ.get('HTTP_X_PARTIAL_XHR')

    if pull_request:

        pull_request_id = pull_request.pull_request_id

    else:

        pull_request_id = None

    status = request.POST.get('changeset_status')

    close_pr = request.POST.get('save_close')

    delete = request.POST.get('save_delete')

    f_path = request.POST.get('f_path')

    line_no = request.POST.get('line')

    if (status or close_pr or delete) and (f_path or line_no):

        # status votes and closing is only possible in general comments

        raise HTTPBadRequest()

    if not allowed_to_change_status:

        if status or close_pr:

            h.flash(_('No permission to change status'), 'error')

            raise HTTPForbidden()

    if pull_request and delete == "delete":

        if (pull_request.owner_id == request.authuser.user_id or

            h.HasPermissionAny('hg.admin')() or

            h.HasRepoPermissionLevel('admin')(pull_request.org_repo.repo_name) or

            h.HasRepoPermissionLevel('admin')(pull_request.other_repo.repo_name)

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request %s') % pull_request_id,

                    category='success')

            return {

               'location': h.url('my_pullrequests'), # or repo pr list?

            }

            raise HTTPFound(location=h.url('my_pullrequests')) # or repo pr list?

        raise HTTPForbidden()

    text = request.POST.get('text', '').strip()

    comment = ChangesetCommentsModel().create(

        text=text,

        repo=c.db_repo.repo_id,

        author=request.authuser.user_id,

        revision=revision,

        pull_request=pull_request_id,

        f_path=f_path or None,

        line_no=line_no or None,

        status_change=ChangesetStatus.get_status_lbl(status) if status else None,

        closing_pr=close_pr,

    )

    if status:

        ChangesetStatusModel().set_status(

            c.db_repo.repo_id,

            status,

            request.authuser.user_id,

            comment,

            revision=revision,

            pull_request=pull_request_id,

        )

    if pull_request:

        action = 'user_commented_pull_request:%s' % pull_request_id

    else:

        action = 'user_commented_revision:%s' % revision

    action_logger(request.authuser, action, c.db_repo, request.ip_addr)

    if pull_request and close_pr:

        PullRequestModel().close_pull_request(pull_request_id)

        action_logger(request.authuser,

                      'user_closed_pull_request:%s' % pull_request_id,

                      c.db_repo, request.ip_addr)

    Session().commit()

    data = {

       'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

    }

    if comment is not None:

        c.comment = comment

        data.update(comment.get_dict())

        data.update({'rendered_text':

                     render('changeset/changeset_comment_block.html')})

    return data

def delete_cs_pr_comment(repo_name, comment_id):

    """Delete a comment from a changeset or pull request"""

    co = ChangesetComment.get_or_404(comment_id)

    if co.repo.repo_name != repo_name:

        raise HTTPNotFound()

    if co.pull_request and co.pull_request.is_closed():

        # don't allow deleting comments on closed pull request

        raise HTTPForbidden()

    owner = co.author_id == request.authuser.user_id

    repo_admin = h.HasRepoPermissionLevel('admin')(repo_name)

    if h.HasPermissionAny('hg.admin')() or repo_admin or owner:

        ChangesetCommentsModel().delete(comment=co)

        Session().commit()

        return True

    else:

        raise HTTPForbidden()

class ChangesetController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(ChangesetController, self)._before(*args, **kwargs)

        c.affected_files_cut_off = 60

    def _index(self, revision, method):

        c.pull_request = None

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.fulldiff = request.GET.get('fulldiff') # for reporting number of changed files

        # get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        enable_comments = True

        c.cs_repo = c.db_repo

        try:

            if len(rev_range) == 2:

                enable_comments = False

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.annotate

~~~~~~~~~~~~~~~~~~~~~~

Annotation library for usage in Kallithea, previously part of vcs

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Dec 4, 2011

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import StringIO

from pygments import highlight

from pygments.formatters import HtmlFormatter

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode

def annotate_highlight(filenode, annotate_from_changeset_func=None,

        order=None, headers=None, **options):

    """

    Returns html portion containing annotated table with 3 columns: line

    numbers, changeset information and pygmentized line of code.

    :param filenode: FileNode object

    :param annotate_from_changeset_func: function taking changeset and

      returning single annotate cell; needs break line at the end

    :param order: ordered sequence of ``ls`` (line numbers column),

      ``annotate`` (annotate column), ``code`` (code column); Default is

      ``['ls', 'annotate', 'code']``

    :param headers: dictionary with headers (keys are whats in ``order``

      parameter)

    """

    from kallithea.lib.pygmentsutils import get_custom_lexer

    options['linenos'] = True

    formatter = AnnotateHtmlFormatter(filenode=filenode, order=order,

        headers=headers,

        annotate_from_changeset_func=annotate_from_changeset_func, **options)

    lexer = get_custom_lexer(filenode.extension) or filenode.lexer

    highlighted = highlight(filenode.content, lexer, formatter)

    return highlighted

class AnnotateHtmlFormatter(HtmlFormatter):

    def __init__(self, filenode, annotate_from_changeset_func=None,

            order=None, **options):

        """

        If ``annotate_from_changeset_func`` is passed it should be a function

        which returns string from the given changeset. For example, we may pass

        following function as ``annotate_from_changeset_func``::

            def changeset_to_anchor(changeset):

                return '<a href="/changesets/%s/">%s</a>\n' % \

                       (changeset.id, changeset.id)

        :param annotate_from_changeset_func: see above

        :param order: (default: ``['ls', 'annotate', 'code']``); order of

          columns;

        :param options: standard pygment's HtmlFormatter options, there is

          extra option tough, ``headers``. For instance we can pass::

             formatter = AnnotateHtmlFormatter(filenode, headers={

                'ls': '#',

                'annotate': 'Annotate',

                'code': 'Code',

             })

        """

        super(AnnotateHtmlFormatter, self).__init__(**options)

        self.annotate_from_changeset_func = annotate_from_changeset_func

        self.order = order or ('ls', 'annotate', 'code')

        headers = options.pop('headers', None)

        if headers and not ('ls' in headers and 'annotate' in headers and

            raise ValueError("If headers option dict is specified it must "

                "all 'ls', 'annotate' and 'code' keys")

        self.headers = headers

        if isinstance(filenode, FileNode):

            self.filenode = filenode

        else:

            raise VCSError("This formatter expect FileNode parameter, not %r"

                % type(filenode))

    def annotate_from_changeset(self, changeset):

        """

        Returns full html line for single changeset per annotated line.

        """

        if self.annotate_from_changeset_func:

            return self.annotate_from_changeset_func(changeset)

        else:

            return ''.join((changeset.id, '\n'))

    def _wrap_tablelinenos(self, inner):

        dummyoutfile = StringIO.StringIO()

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1

            dummyoutfile.write(line)

        fl = self.linenostart

        mw = len(str(lncount + fl - 1))

        sp = self.linenospecial

        st = self.linenostep

        la = self.lineanchors

        aln = self.anchorlinenos

        if sp:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if i % sp == 0:

                        if aln:

                            lines.append('<a href="#%s-%d" class="special">'

                                         '%*d</a>' %

                                         (la, i, mw, i))

                        else:

                            lines.append('<span class="special">'

                                         '%*d</span>' % (mw, i))

                    else:

                        if aln:

                            lines.append('<a href="#%s-%d">'

                                         '%*d</a>' % (la, i, mw, i))

                        else:

                            lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        else:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                        lines.append('<a href="#%s-%d">%*d</a>'

                                     % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

#        annotate_changesets = [tup[1] for tup in self.filenode.annotate]

#        # TODO: not sure what that fixes

#        # If pygments cropped last lines break we need do that too

#        ln_cs = len(annotate_changesets)

#        ln_ = len(ls.splitlines())

#        if  ln_cs > ln_:

#            annotate_changesets = annotate_changesets[:ln_ - ln_cs]

        annotate = ''.join((self.annotate_from_changeset(el[2]())

                            for el in self.filenode.annotate))

        # in case you wonder about the seemingly redundant <div> here:

        # since the content in the other cell also is wrapped in a div,

        # some browsers in some configurations seem to mess up the formatting.

        '''

        yield 0, ('<table class="%stable">' % self.cssclass +

                  '<tr><td class="linenos"><div class="linenodiv"><pre>' +

                  ls + '</pre></div></td>' +

                  '<td class="code">')

        yield 0, dummyoutfile.getvalue()

        yield 0, '</td></tr></table>'

        '''

        headers_row = []

        if self.headers:

            headers_row = ['<tr class="annotate-header">']

            for key in self.order:

                td = ''.join(('<td>', self.headers[key], '</td>'))

                headers_row.append(td)

            headers_row.append('</tr>')

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.middleware.simplegit

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

SimpleGit middleware for handling Git protocol requests (push/clone etc.)

It's implemented with basic auth function

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 28, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import re

from kallithea.lib.base import BaseVCSController

from kallithea.lib.hooks import log_pull_action

from kallithea.lib.middleware.pygrack import make_wsgi_app

from kallithea.lib.utils import make_ui

from kallithea.lib.utils2 import safe_unicode

from kallithea.model.db import Repository

log = logging.getLogger(__name__)

GIT_PROTO_PAT = re.compile(r'^/(.+)/(info/refs|git-upload-pack|git-receive-pack)$')

cmd_mapping = {

    'git-receive-pack': 'push',

    'git-upload-pack': 'pull',

}

class SimpleGit(BaseVCSController):

    scm_alias = 'git'

    @classmethod

    def parse_request(cls, environ):

        path_info = environ.get('PATH_INFO', '')

        m = GIT_PROTO_PAT.match(path_info)

        if m is None:

            return None

        class parsed_request(object):

            # See https://git-scm.com/book/en/v2/Git-Internals-Transfer-Protocols#_the_smart_protocol

            repo_name = safe_unicode(m.group(1).rstrip('/'))

            cmd = m.group(2)

            query_string = environ['QUERY_STRING']

            if cmd == 'info/refs' and query_string.startswith('service='):

                service = query_string.split('=', 1)[1]

                action = cmd_mapping.get(service)

            else:

                service = None

                action = cmd_mapping.get(cmd)

        return parsed_request

    def _make_app(self, parsed_request):

        """

        Return a pygrack wsgi application.

        """

        pygrack_app = make_wsgi_app(parsed_request.repo_name, self.basepath)

        def wrapper_app(environ, start_response):

            if (parsed_request.cmd == 'info/refs' and

                parsed_request.service == 'git-upload-pack'

                baseui = make_ui()

                repo = Repository.get_by_repo_name(parsed_request.repo_name)

                scm_repo = repo.scm_instance

                # Run hooks, like Mercurial outgoing.pull_logger does

                log_pull_action(ui=baseui, repo=scm_repo._repo)

            # Note: push hooks are handled by post-receive hook

            return pygrack_app(environ, start_response)

        return wrapper_app

    """

    def __init__(self, *args, **kwargs):

        kwargs.setdefault('url', url.current)

        _Page.__init__(self, *args, **kwargs)

    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):

        """

        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

        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(HTML.li(self._pagerlink(self.first_page, 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 nolink_attr is set

            text_ = '..'

            if self.dotdot_attr:

                text_ = HTML.span(c=text_, **self.dotdot_attr)

            nav_items.append(HTML.li(text_))

        for thispage in xrange(leftmost_page, rightmost_page + 1):

            # Highlight the current page number and do not use a link

            text_ = str(thispage)

            if thispage == self.page:

                # Wrap in a SPAN tag if nolink_attr is set

                if self.curpage_attr:

                    text_ = HTML.li(HTML.span(c=text_), **self.curpage_attr)

                nav_items.append(text_)

            # Otherwise create just a link to that page

            else:

                nav_items.append(HTML.li(self._pagerlink(thispage, text_)))

        # 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(HTML.li(text_))

        # 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(HTML.li(self._pagerlink(self.last_page, self.last_page)))

        #_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 pager(self, format='<ul class="pagination">$link_previous ~2~ $link_next</ul>', page_param='page', partial_param='partial',

        show_if_single_page=False, separator=' ', onclick=None,

        symbol_first='<<', symbol_last='>>',

        symbol_previous='<', symbol_next='>',

        link_attr=None,

        curpage_attr=None,

        self.curpage_attr = curpage_attr or {'class': 'active'}

        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 or {'class': 'pager_link', 'rel': 'prerender'}

        self.dotdot_attr = dotdot_attr or {'class': 'pager_dotdot'}

        # 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)

        # 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': HTML.li(self.previous_page and

                    self._pagerlink(self.previous_page, symbol_previous)

                    or HTML.a(symbol_previous)),

            'link_next': HTML.li(self.next_page and

                    self._pagerlink(self.next_page, symbol_next)

                    or HTML.a(symbol_next))

        })

        return literal(result)

class RepoPage(Page):

    def __init__(self, collection, page=1, items_per_page=20,

                 item_count=None, **kwargs):

        """Create a "RepoPage" instance. special pager for paging

        repository

        """

        # TODO: call baseclass __init__

        self._url_generator = kwargs.pop('url', url.current)

        # 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):

            log.error("Invalid page value: %r", page)

            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