class CompareController(BaseRepoController):

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

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

        # The base repository has already been retrieved.

        c.a_repo = c.db_repo

        # Retrieve the "changeset" repository (default: same as base).

        other_repo = request.GET.get('other_repo', None)

        if other_repo is None:

            c.cs_repo = c.a_repo

        else:

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

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

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

        elif alias == 'git':

            if org_repo != other_repo:

                from dulwich.repo import Repo

                from dulwich.client import SubprocessGitClient

                gitrepo = Repo(org_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(safe_str(other_repo.path), gitrepo)

                gitrepo_remote = Repo(other_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(safe_str(org_repo.path), gitrepo_remote)

                revs = [

                    x.commit.id

                    for x in gitrepo_remote.get_walker(include=[other_rev],

                                                       exclude=[org_rev])

                ]

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

                if other_changesets:

                    ancestors = [other_changesets[0].parents[0].raw_id]

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestors = [other_rev]

                gitrepo.close()

                gitrepo_remote.close()