org_changesets = []

            other_changesets = []

            ancestor = org_rev

        elif alias == 'hg':

            #case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.unionrepository(other_repo.baseui,

                                                   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

            if org_repo.EMPTY_CHANGESET in (org_rev, other_rev):

                # work around unexpected Mercurial behaviour

                ancestor = org_repo.EMPTY_CHANGESET

            else:

                ancestors = hgrepo.revs("ancestor(id(%s), id(%s))", org_rev, other_rev)

                if ancestors:

                    # FIXME: picks arbitrary ancestor - but there is usually only one

                    ancestor = hgrepo[ancestors[0]].hex()

            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(other_repo.path, gitrepo)

                gitrepo_remote = Repo(other_repo.path)

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

                revs = []

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

                                                   exclude=[org_rev]):

          branch would be used.

        :raises ``CommitError``: if any error occurs while committing

        """

        self.check_integrity(parents)

        from .repository import MercurialRepository

        if not isinstance(message, unicode) or not isinstance(author, unicode):

            raise RepositoryError('Given message and author needs to be '

                                  'an <unicode> instance got %r & %r instead'

                                  % (type(message), type(author)))

        if branch is None:

            branch = MercurialRepository.DEFAULT_BRANCH_NAME

        kwargs['branch'] = branch

        def filectxfn(_repo, memctx, path):

            """

            Marks given path as added/changed/removed in a given _repo. This is

            for internal mercurial commit function.

            """

            # check if this path is removed

            if path in (node.path for node in self.removed):

                raise IOError(errno.ENOENT, '%s is deleted' % path)

            # check if this path is added

            for node in self.added:

                if node.path == path:

                    return memfilectx(_repo, path=node.path,

                        data=(node.content.encode('utf8')

                              if not node.is_binary else node.content),

                        islink=False,

                        isexec=node.is_executable,

                        copied=False)

            # or changed

            for node in self.changed:

                if node.path == path:

                    return memfilectx(_repo, path=node.path,

                        data=(node.content.encode('utf8')

                              if not node.is_binary else node.content),

                        islink=False,

                        isexec=node.is_executable,

                        copied=False)

            raise RepositoryError("Given path haven't been marked as added,"

                                  "changed or removed (%s)" % path)

        """

        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:

            revision = revs[-1]

        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 = str(url)

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

            raise RepositoryError("Start revision '%s' cannot be "

                                  "after end revision '%s'" % (start, end))

        if branch_name and branch_name not in self.allbranches.keys():

            msg = ("Branch %s not found in %s" % (branch_name, self))

            raise BranchDoesNotExistError(msg)

        if end_pos is not None:

            end_pos += 1

        #filter branches

        filter_ = []

        if branch_name:

            filter_.append('branch("%s")' % (branch_name))

        if start_date and not end_date:

            filter_.append('date(">%s")' % start_date)

        if end_date and not start_date:

            filter_.append('date("<%s")' % end_date)

        if start_date and end_date:

            filter_.append('date(">%s") and date("<%s")' % (start_date, end_date))

        if filter_:

            revisions = scmutil.revrange(self._repo, filter_)

        else:

            revisions = self.revisions

        if reverse:

            revs = reversed(revs)

        return CollectionGenerator(self, revs)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        try:

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

        except Abort, 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):