repos, branches, bookmarks or tips

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: May 6, 2012

:author: marcink

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

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

"""

import logging

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.model.db import Repository

log = logging.getLogger(__name__)

class CompareController(BaseRepoController):

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

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

        # The base repository has already been retrieved.

            c.cs_repo = Repository.get_by_repo_name(other_repo)

            if c.cs_repo is None:

                msg = _('Could not find other repository %s') % other_repo

                h.flash(msg, category='error')

                raise HTTPFound(location=url('compare_home', repo_name=c.a_repo.repo_name))

        # Verify that it's even possible to compare these two repositories.

        if c.a_repo.scm_instance.alias != c.cs_repo.scm_instance.alias:

            msg = _('Cannot compare repositories of different types')

            h.flash(msg, category='error')

            raise HTTPFound(location=url('compare_home', repo_name=c.a_repo.repo_name))

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name):

        c.compare_home = True

        c.a_ref_name = c.cs_ref_name = None

        return render('compare/compare_diff.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def compare(self, repo_name, org_ref_type, org_ref_name, other_ref_type, other_ref_name):

        org_ref_name = org_ref_name.strip()

        other_ref_name = other_ref_name.strip()

        diff_context_size = h.get_diff_context_size(request.GET)

        c.a_rev = self._get_ref_rev(c.a_repo, org_ref_type, org_ref_name,

            returnempty=True)

        c.cs_rev = self._get_ref_rev(c.cs_repo, other_ref_type, other_ref_name)

        c.compare_home = False

        c.a_ref_name = org_ref_name

        c.a_ref_type = org_ref_type

        c.cs_ref_name = other_ref_name

        c.cs_ref_type = other_ref_type

        raw_ids = [x.raw_id for x in c.cs_ranges]

        c.cs_comments = c.cs_repo.get_comments(raw_ids)

        c.cs_statuses = c.cs_repo.statuses(raw_ids)

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = graph_data(c.cs_repo.scm_instance, revs)

        if partial:

            return render('compare/compare_cs.html')

        org_repo = c.a_repo

        other_repo = c.cs_repo

        Returns iterator of ``BaseChangeset`` objects from start to end,

        both inclusive.

        :param start: None or str

        :param end: None or str

        :param start_date:

        :param end_date:

        :param branch_name:

        :param reversed:

        """

        raise NotImplementedError

    def __getitem__(self, key):

        if isinstance(key, slice):

            return (self.get_changeset(rev) for rev in self.revisions[key])

        return self.get_changeset(key)

    def count(self):

        return len(self.revisions)

    def tag(self, name, user, revision=None, message=None, date=None, **opts):

        """

        Creates and returns a tag for the given ``revision``.

import errno

import logging

import os

import re

import time

import urllib.error

import urllib.parse

import urllib.request

from collections import OrderedDict

import mercurial.util  # import url as hg_url

from dulwich.config import ConfigFile

from dulwich.objects import Tag

from dulwich.repo import NotGitRepository, Repo

from dulwich.server import update_server_info

from kallithea.lib.vcs import subprocessio

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError,

                                          TagDoesNotExistError)

from kallithea.lib.vcs.utils.helpers import get_urllib_request_handlers

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import abspath, get_user_home

from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

from .workdir import GitWorkdir

SHA_PATTERN = re.compile(r'^([0-9a-fA-F]{12}|[0-9a-fA-F]{40})$')

log = logging.getLogger(__name__)

        if None not in [start, end] and start_pos > end_pos:

            raise RepositoryError('start cannot be after end')

        if end_pos is not None:

            end_pos += 1

        revs = revs[start_pos:end_pos]

        if reverse:

            revs.reverse()

        return CollectionGenerator(self, revs)

    def get_diff(self, rev1, rev2, path=None, ignore_whitespace=False,

                 context=3):

        """

        Returns (git like) *diff*, as plain bytes text. Shows changes

        introduced by ``rev2`` since ``rev1``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

          the changes since empty state of the repository until ``rev2``

        :param rev2: Until which revision changes should be shown.

        :param ignore_whitespace: If set to ``True``, would not show whitespace

          changes. Defaults to ``False``.

import mercurial.hg

import mercurial.hgweb

import mercurial.httppeer

import mercurial.localrepo

import mercurial.match

import mercurial.mdiff

import mercurial.node

import mercurial.patch

import mercurial.scmutil

import mercurial.sshpeer

import mercurial.tags

import mercurial.ui

import mercurial.util

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.exceptions import (BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError,

                                          TagDoesNotExistError, VCSError)

from kallithea.lib.vcs.utils.helpers import get_urllib_request_handlers

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import abspath

from .changeset import MercurialChangeset

from .inmemory import MercurialInMemoryChangeset

from .workdir import MercurialWorkdir

log = logging.getLogger(__name__)

            revisions = mercurial.scmutil.revrange(self._repo, [revspec])

        else:

            revisions = self.revisions

        # this is very much a hack to turn this into a list; a better solution

        # would be to get rid of this function entirely and use revsets

        revs = list(revisions)[start_pos:end_pos]

        if reverse:

            revs.reverse()

        return CollectionGenerator(self, revs)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        other = mercurial.hg.peer(self._repo, {}, safe_bytes(self._get_url(url)))

        try:

            mercurial.exchange.pull(self._repo, other, heads=None, force=None)

        except mercurial.error.Abort as err:

            # Propagate error but with vcs's type

            raise RepositoryError(str(err))

    @LazyProperty

        """Performs authorization check with only the minimum amount of

        information needed for such a check, rather than a full command

        object.

        """

        if (h.HasRepoPermissionLevel('read')(org_repo.repo_name) and

            h.HasRepoPermissionLevel('read')(other_repo.repo_name)

        ):

            return True

        return False

    def __init__(self, org_repo, other_repo, org_ref, other_ref, title, description, owner, reviewers):

        reviewers = set(reviewers)

        _assert_valid_reviewers(reviewers)

        (org_ref_type,

         org_ref_name,

         org_rev) = org_ref.split(':')

        org_display = h.short_ref(org_ref_type, org_ref_name)

        if org_ref_type == 'rev':

            cs = org_repo.scm_instance.get_changeset(org_rev)

            org_ref = 'branch:%s:%s' % (cs.branch, cs.raw_id)

        (other_ref_type,

         other_ref_name,

         other_rev) = other_ref.split(':')

        if other_ref_type == 'rev':

            cs = other_repo.scm_instance.get_changeset(other_rev)

            other_ref_name = cs.raw_id[:12]

            other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, cs.raw_id)

        other_display = h.short_ref(other_ref_type, other_ref_name)

        cs_ranges, _cs_ranges_not, ancestor_revs = \

        if not cs_ranges:

            raise self.Empty(_('Cannot create empty pull request'))

        if not ancestor_revs:

            ancestor_rev = org_repo.scm_instance.EMPTY_CHANGESET

        elif len(ancestor_revs) == 1:

            ancestor_rev = ancestor_revs[0]

        else:

            raise self.AmbiguousAncestor(

                _('Cannot create pull request - criss cross merge detected, please merge a later %s revision to %s')

                % (other_ref_name, org_ref_name))