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

    @staticmethod

    def _get_changesets(alias, org_repo, org_rev, other_repo, other_rev):

        """

        Returns lists of changesets that can be merged from org_repo@org_rev

        to other_repo@other_rev

        ... and the other way

        ... and the ancestors that would be used for merge

        :param org_repo: repo object, that is most likely the original repo we forked from

        :param org_rev: the revision we want our compare to be made

        :param other_repo: repo object, most likely the fork of org_repo. It has

            all changesets that we need to obtain

        :param other_rev: revision we want out compare to be made on other_repo

        """

        ancestors = None

        if org_rev == other_rev:

            org_changesets = []

            other_changesets = []

        elif alias == 'hg':

            # case two independent repos

            if org_repo != other_repo:

                                                       other_repo.path,

                                                       org_repo.path)

                # all ancestors of other_rev will be in other_repo and

                # rev numbers from hgrepo can be used in other_repo - org_rev ancestors cannot

            # no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            ancestors = [hgrepo[ancestor].hex() for ancestor in

                         hgrepo.revs("id(%s) & ::id(%s)", other_rev, org_rev)]

            if ancestors:

                log.debug("shortcut found: %s is already an ancestor of %s", other_rev, org_rev)

            else:

                log.debug("no shortcut found: %s is not an ancestor of %s", other_rev, org_rev)

                ancestors = [hgrepo[ancestor].hex() for ancestor in

                             hgrepo.revs("heads(::id(%s) & ::id(%s))", org_rev, other_rev)] # FIXME: expensive!

            other_revs = hgrepo.revs("ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

                                     other_rev, org_rev, org_rev)

            other_changesets = [other_repo.get_changeset(rev) for rev in other_revs]

            org_revs = hgrepo.revs("ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

                                   org_rev, other_rev, other_rev)

            org_changesets = [org_repo.get_changeset(hgrepo[rev].hex()) for rev in org_revs]

                    c.cs_branch_name = org_scm_instance.get_changeset(c.cs_ref_name).branch # use ref_type ?

                c.a_branch_name = c.a_ref_name

                if c.a_ref_type != 'branch':

                    try:

                        c.a_branch_name = other_scm_instance.get_changeset(c.a_ref_name).branch # use ref_type ?

                    except EmptyRepositoryError:

                        c.a_branch_name = 'null' # not a branch name ... but close enough

                # candidates: descendants of old head that are on the right branch

                #             and not are the old head itself ...

                #             and nothing at all if old head is a descendant of target ref name

                if not c.is_range and other_scm_instance._repo.revs('present(%s)::&%s', c.cs_ranges[-1].raw_id, c.a_branch_name):

                    c.update_msg = _('This pull request has already been merged to %s.') % c.a_branch_name

                elif c.pull_request.is_closed():

                    c.update_msg = _('This pull request has been closed and can not be updated.')

                else: # look for descendants of PR head on source branch in org repo

                    avail_revs = org_scm_instance._repo.revs('%s:: & branch(%s)',

                                                             revs[0], c.cs_branch_name)

                    if len(avail_revs) > 1: # more than just revs[0]

                        # also show changesets that not are descendants but would be merged in

                        targethead = other_scm_instance.get_changeset(c.a_branch_name).raw_id

                        if org_scm_instance.path != other_scm_instance.path:

                            # Note: org_scm_instance.path must come first so all

                            # valid revision numbers are 100% org_scm compatible

                            # - both for avail_revs and for revset results

                                                                   org_scm_instance.path,

                                                                   other_scm_instance.path)

                        else:

                            hgrepo = org_scm_instance._repo

                        show = set(hgrepo.revs('::%ld & !::parents(%s) & !::%s',

                                               avail_revs, revs[0], targethead))

                        if show:

                            c.update_msg = _('The following additional changes are available on %s:') % c.cs_branch_name

                        else:

                            c.update_msg = _('No additional changesets found for iterating on this pull request.')

                    else:

                        show = set()

                        avail_revs = set() # drop revs[0]

                        c.update_msg = _('No additional changesets found for iterating on this pull request.')

                    # TODO: handle branch heads that not are tip-most

                    brevs = org_scm_instance._repo.revs('%s - %ld - %s', c.cs_branch_name, avail_revs, revs[0])

                    if brevs:

                        # also show changesets that are on branch but neither ancestors nor descendants

                        show.update(org_scm_instance._repo.revs('::%ld - ::%ld - ::%s', brevs, avail_revs, c.a_branch_name))

                        show.add(revs[0]) # make sure graph shows this so we can see how they relate

                        c.update_msg_other = _('Note: Branch %s has another head: %s.') % (c.cs_branch_name,

                            h.short_id(org_scm_instance.get_changeset((max(brevs))).raw_id))

        self.nodes = {}

    @LazyProperty

    def tags(self):

        return [safe_unicode(tag) for tag in self._ctx.tags()]

    @LazyProperty

    def branch(self):

        return safe_unicode(self._ctx.branch())

    @LazyProperty

    def branches(self):

        return [safe_unicode(self._ctx.branch())]

    @LazyProperty

    def closesbranch(self):

        return self._ctx.closesbranch()

    @LazyProperty

    def obsolete(self):

        return self._ctx.obsolete()

    @LazyProperty

    def bumped(self):

    @LazyProperty

    def divergent(self):

    @LazyProperty

    def extinct(self):

        return self._ctx.extinct()

    @LazyProperty

    def unstable(self):

    @LazyProperty

    def phase(self):

        if(self._ctx.phase() == 1):

            return 'Draft'

        elif(self._ctx.phase() == 2):

            return 'Secret'

        else:

            return ''

    @LazyProperty

    def successors(self):

        successors = obsutil.successorssets(self._ctx._repo, self._ctx.node(), closest=True)

        if successors:

            # flatten the list here handles both divergent (len > 1)

            # and the usual case (len = 1)

            successors = [hex(n)[:12] for sub in successors for n in sub if n != self._ctx.node()]

        return successors

    @LazyProperty

    def predecessors(self):

        return [hex(n)[:12] for n in obsutil.closestpredecessors(self._ctx._repo, self._ctx.node())]

        return self.get_file_history(path, limit=1)[0]

    def get_file_history(self, path, limit=None):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        """

        fctx = self._get_filectx(path)

        hist = []

        cnt = 0

        for cs in reversed([x for x in fctx.filelog()]):

            cnt += 1

            hist.append(hex(fctx.filectx(cs).node()))

            if limit is not None and cnt == limit:

                break

        return [self.repository.get_changeset(node) for node in hist]

    def get_file_annotate(self, path):

        """

        Returns a generator of four element tuples with

            lineno, sha, changeset lazy loader and line

        """

        annotations = self._get_filectx(path).annotate()

        for i, (fctx, l) in enumerate(annotation_lines):

            sha = fctx.hex()

            yield (i + 1, sha, lambda sha=sha, l=l: self.repository.get_changeset(sha), l)

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

        Fills up given stream.

        :param stream: file like object.

        :param kind: one of following: ``zip``, ``tgz`` or ``tbz2``.

            Default: ``tgz``.

        :param prefix: name of root directory in archive.

            Default is repository name and changeset's raw_id joined with dash

            (``repo-tip.<KIND>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

        :raise VcsError: If given stream is None

        """

        allowed_kinds = settings.ARCHIVE_SPECS

        if kind not in allowed_kinds:

            raise ImproperArchiveTypeError('Archive kind not supported use one'

                'of %s' % ' '.join(allowed_kinds))

            if os.path.exists(cl_path):

                return os.stat(cl_path).st_mtime

            else:

                return os.stat(st_path).st_mtime

    def _get_revision(self, revision):

        """

        Gets an ID revision given as str. This will always return a full

        40 char revision number

        :param revision: str or int or None

        """

        if isinstance(revision, unicode):

            revision = safe_str(revision)

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, None]:

            revision = 'tip'

        try:

            if isinstance(revision, int):

                return self._repo[revision].hex()

        except (IndexError, ValueError, RepoLookupError, TypeError):

            msg = ("Revision %s does not exist for %s" % (revision, self))

            raise ChangesetDoesNotExistError(msg)

        except (LookupError, ):

            msg = ("Ambiguous identifier `%s` for %s" % (revision, self))

            raise ChangesetDoesNotExistError(msg)

    def get_ref_revision(self, ref_type, ref_name):

        """

        Returns revision number for the given reference.

        """

        ref_name = safe_str(ref_name)

        if ref_type == 'rev' and not ref_name.strip('0'):

            return self.EMPTY_CHANGESET

        # lookup up the exact node id

        _revset_predicates = {

                'branch': 'branch',

                'book': 'bookmark',

                'tag': 'tag',

                'rev': 'id',

            }

        # avoid expensive branch(x) iteration over whole repo

        rev_spec = "%%s & %s(%%s)" % _revset_predicates[ref_type]

        try:

            revs = self._repo.revs(rev_spec, ref_name, ref_name)

        except LookupError:

            msg = ("Ambiguous identifier %s:%s for %s" % (ref_type, ref_name, self.name))

            raise ChangesetDoesNotExistError(msg)

        except RepoLookupError:

            msg = ("Revision %s:%s does not exist for %s" % (ref_type, ref_name, self.name))

            raise ChangesetDoesNotExistError(msg)

        if revs:

        else:

            # TODO: just report 'not found'?

            revision = ref_name

        return self._get_revision(revision)

    def _get_archives(self, archive_name='tip'):

        allowed = self.baseui.configlist("web", "allow_archive",

                                         untrusted=True)

        for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:

            if i[0] in allowed or self._repo.ui.configbool("web",

                                                           "allow" + i[0],

                                                           untrusted=True):

                yield {"type": i[0], "extension": i[1], "node": archive_name}

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall

        to filesystem

        (``file:///``) schema.

        """

        url = safe_str(url)

        if url != 'default' and '://' not in url:

            url = "file:" + urllib.pathname2url(url)

                revspec = ' and '.join(filter_)

            else:

                revspec = 'all()'

            if max_revisions:

                revspec = 'limit(%s, %s)' % (revspec, max_revisions)

            revisions = 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.

        """

        url = self._get_url(url)

        other = peer(self._repo, {}, url)

        try:

            from mercurial import exchange

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

        except Abort as err:

            # Propagate error but with vcs's type

            raise RepositoryError(str(err))

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return MercurialWorkdir(self)

    def get_config_value(self, section, name=None, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

        elif isinstance(config_file, basestring):

            config_file = [config_file]

# -*- 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/>.

import logging

from mercurial import hg

from kallithea.lib.utils import make_ui

from kallithea.lib.utils2 import safe_str, safe_unicode

from kallithea.lib.vcs.backends.ssh import BaseSshHandler

log = logging.getLogger(__name__)

class MercurialSshHandler(BaseSshHandler):

    vcs_type = 'hg'

    @classmethod

    def make(cls, ssh_command_parts):

        r"""

        >>> import shlex

        >>> MercurialSshHandler.make(shlex.split('hg -R "foo bar" serve --stdio')).repo_name

        u'foo bar'

        >>> MercurialSshHandler.make(shlex.split(' hg -R blåbærgrød serve --stdio ')).repo_name

        u'bl\xe5b\xe6rgr\xf8d'

        >>> MercurialSshHandler.make(shlex.split('''hg -R 'foo"bar' serve --stdio''')).repo_name

        u'foo"bar'

        >>> MercurialSshHandler.make(shlex.split('/bin/hg -R "foo" serve --stdio'))

        >>> MercurialSshHandler.make(shlex.split('''hg -R "foo"bar" serve --stdio''')) # ssh-serve will report: Error parsing SSH command "...": invalid syntax

        Traceback (most recent call last):

        ValueError: No closing quotation

        >>> MercurialSshHandler.make(shlex.split('git-upload-pack "/foo"')) # not handled here

        """

"""

Mercurial libs compatibility

"""

import mercurial

from mercurial import archival, config, demandimport, discovery, httppeer, localrepo

from mercurial import merge as hg_merge

from mercurial import obsutil, patch, scmutil, sshpeer, ui, unionrepo

from mercurial.commands import clone, nullid, pull

from mercurial.context import memctx, memfilectx

from mercurial.discovery import findcommonoutgoing

from mercurial.encoding import tolocal

from mercurial.error import Abort, RepoError, RepoLookupError

from mercurial.hg import peer

from mercurial.hgweb import hgweb_mod

from mercurial.hgweb.common import get_contact

from mercurial.match import exact as match_exact

from mercurial.match import match

from mercurial.mdiff import diffopts

from mercurial.node import hex, nullrev

from mercurial.scmutil import revrange

from mercurial.tags import tag

from mercurial.url import httpbasicauthhandler, httpdigestauthhandler

from mercurial.util import url as hg_url

localrepo.localrepository._lfstatuswriters = [lambda *msg, **opts: None]

# 3.5 7699d3212994 added the invariant that repo.lfstatus must exist before hitting overridearchive

localrepo.localrepository.lfstatus = False

requirements = [

    "alembic >= 0.8.0, < 1.1",

    "gearbox >= 0.1.0, < 1",

    "waitress >= 0.8.8, < 1.4",

    "WebOb >= 1.7, < 1.9",

    "backlash >= 0.1.2, < 1",

    "TurboGears2 >= 2.3.10, < 2.5",

    "tgext.routes >= 0.2.0, < 1",

    "Beaker >= 1.7.0, < 2",

    "WebHelpers2 >= 2.0, < 2.1",

    "FormEncode >= 1.3.0, < 1.4",

    "SQLAlchemy >= 1.1, < 1.4",

    "Mako >= 0.9.0, < 1.1",

    "Pygments >= 2.2.0, < 2.5",

    "Whoosh >= 2.5.0, < 2.8",

    "celery >= 3.1, < 4.0", # TODO: celery 4 doesn't work

    "Babel >= 1.3, < 2.8",

    "python-dateutil >= 1.5.0, < 2.9",

    "Markdown >= 2.2.1, < 3.2",

    "docutils >= 0.11, < 0.15",

    "URLObject >= 2.3.4, < 2.5",

    "Routes >= 2.0, < 2.5",

    "dulwich >= 0.14.1, < 0.20",

    "decorator >= 3.3.2, < 4.5",

    "Paste >= 2.0.3, < 3.1",

    "bleach >= 3.0, < 3.2",

    "Click >= 7.0, < 8",

    "ipaddr >= 2.1.10, < 2.3",

    "paginate >= 0.5, < 0.6",

    "paginate_sqlalchemy >= 0.3.0, < 0.4",

]

if not is_windows:

    requirements.append("bcrypt >= 3.1.0, < 3.2")

dependency_links = [

]

classifiers = [

    'Development Status :: 4 - Beta',

    'Environment :: Web Environment',

    'Framework :: Pylons',

    'Intended Audience :: Developers',

    'License :: OSI Approved :: GNU General Public License (GPL)',

    'Operating System :: OS Independent',

    'Programming Language :: Python',

    'Programming Language :: Python :: 2.7',