/brz/remove-bazaar

# Copyright (C) 2007 Canonical Ltd

# Copyright (C) 2009-2010 Jelmer Vernooij <jelmer@samba.org>

#

# 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 2 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, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""An adapter between a Git Branch and a Bazaar Branch"""

from collections import defaultdict

from dulwich.objects import (

    Commit,

    Tag,

    ZERO_SHA,

    )

from bzrlib import (

    branch,

    bzrdir,

    config,

    errors,

    repository as _mod_repository,

    revision,

    tag,

    transport,

    )

from bzrlib.decorators import (

    needs_read_lock,

    )

from bzrlib.revision import (

    NULL_REVISION,

    )

from bzrlib.trace import (

    is_quiet,

    mutter,

    )

from bzrlib.plugins.git.config import (

    GitBranchConfig,

    )

from bzrlib.plugins.git.errors import (

    NoPushSupport,

    NoSuchRef,

    )

from bzrlib.plugins.git.refs import (

    branch_name_to_ref,

    extract_tags,

    is_tag,

    ref_to_branch_name,

    ref_to_tag_name,

    tag_name_to_ref,

    UnpeelMap,

    )

from bzrlib.foreign import ForeignBranch

class GitPullResult(branch.PullResult):

    """Result of a pull from a Git branch."""

    def _lookup_revno(self, revid):

        assert isinstance(revid, str), "was %r" % revid

        # Try in source branch first, it'll be faster

        return self.target_branch.revision_id_to_revno(revid)

    @property

    def old_revno(self):

        return self._lookup_revno(self.old_revid)

    @property

    def new_revno(self):

        return self._lookup_revno(self.new_revid)

class GitTags(tag.BasicTags):

    """Ref-based tag dictionary."""

    def __init__(self, branch):

        self.branch = branch

        self.repository = branch.repository

    def get_refs(self):

        raise NotImplementedError(self.get_refs)

    def _iter_tag_refs(self, refs):

        raise NotImplementedError(self._iter_tag_refs)

    def _merge_to_git(self, to_tags, refs, overwrite=False):

        target_repo = to_tags.repository

        conflicts = []

        for k, v in refs.iteritems():

            if not is_tag(k):

                continue

            if overwrite or not k in target_repo._git.refs:

                target_repo._git.refs[k] = v

            elif target_repo._git.refs[k] == v:

                pass

            else:

                conflicts.append((ref_to_tag_name(k), v, target_repo.refs[k]))

        return conflicts

    def _merge_to_non_git(self, to_tags, refs, overwrite=False):

        unpeeled_map = defaultdict(set)

        conflicts = []

        result = dict(to_tags.get_tag_dict())

        for n, peeled, unpeeled, bzr_revid in self._iter_tag_refs(refs):

            if unpeeled is not None:

                unpeeled_map[peeled].add(unpeeled)

            if n not in result or overwrite:

                result[n] = bzr_revid

            elif result[n] == bzr_revid:

                pass

            else:

                conflicts.append((n, result[n], bzr_revid))

        to_tags._set_tag_dict(result)

        if len(unpeeled_map) > 0:

            map_file = UnpeelMap.from_repository(to_tags.branch.repository)

            map_file.update(unpeeled_map)

            map_file.save_in_repository(to_tags.branch.repository)

        return conflicts

    def merge_to(self, to_tags, overwrite=False, ignore_master=False,

                 source_refs=None):

        """See Tags.merge_to."""

        if source_refs is None:

            source_refs = self.get_refs()

        if self == to_tags:

            return

        if isinstance(to_tags, GitTags):

            return self._merge_to_git(to_tags, source_refs,

                                      overwrite=overwrite)

        else:

            if ignore_master:

                master = None

            else:

                master = to_tags.branch.get_master_branch()

            conflicts = self._merge_to_non_git(to_tags, source_refs,

                                              overwrite=overwrite)

            if master is not None:

                conflicts += self.merge_to(master.tags, overwrite=overwrite,

                                           source_refs=source_refs,

                                           ignore_master=ignore_master)

            return conflicts

    def get_tag_dict(self):

        ret = {}

        refs = self.get_refs()

        for (name, peeled, unpeeled, bzr_revid) in self._iter_tag_refs(refs):

            ret[name] = bzr_revid

        return ret

class LocalGitTagDict(GitTags):

    """Dictionary with tags in a local repository."""

    def __init__(self, branch):

        super(LocalGitTagDict, self).__init__(branch)

        self.refs = self.repository._git.refs

    def get_refs(self):

        return self.repository._git.get_refs()

    def _iter_tag_refs(self, refs):

        """Iterate over the tag refs.

        :param refs: Refs dictionary (name -> git sha1)

        :return: iterator over (name, peeled_sha1, unpeeled_sha1, bzr_revid)

        """

        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():

            try:

                obj = self.repository._git[peeled]

            except KeyError:

                mutter("Tag %s points at unknown object %s, ignoring", peeled,

                       obj)

                continue

            # FIXME: this shouldn't really be necessary, the repository

            # already should have these unpeeled.

            while isinstance(obj, Tag):

                peeled = obj.object[1]

                obj = self.repository._git[peeled]

            if not isinstance(obj, Commit):

                mutter("Tag %s points at object %r that is not a commit, "

                       "ignoring", k, obj)

                continue

            yield (k, peeled, unpeeled,

                   self.branch.lookup_foreign_revision_id(peeled))

    def _set_tag_dict(self, to_dict):

        extra = set(self.get_refs().keys())

        for k, revid in to_dict.iteritems():

            name = tag_name_to_ref(k)

            if name in extra:

                extra.remove(name)

            self.set_tag(k, revid)

        for name in extra:

            if is_tag(name):

                del self.repository._git[name]

    def set_tag(self, name, revid):

        self.refs[tag_name_to_ref(name)], _ = \

            self.branch.lookup_bzr_revision_id(revid)

class DictTagDict(tag.BasicTags):

    def __init__(self, branch, tags):

        super(DictTagDict, self).__init__(branch)

        self._tags = tags

    def get_tag_dict(self):

        return self._tags

class GitBranchFormat(branch.BranchFormat):

    def get_format_description(self):

        return 'Git Branch'

    def network_name(self):

        return "git"

    def supports_tags(self):

        return True

    def supports_leaving_lock(self):

        return False

    @property

    def _matchingbzrdir(self):

        from bzrlib.plugins.git.dir import LocalGitControlDirFormat

        return LocalGitControlDirFormat()

    def get_foreign_tests_branch_factory(self):

        from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory

        return ForeignTestsBranchFactory()

    def make_tags(self, branch):

        if getattr(branch.repository, "get_refs", None) is not None:

            from bzrlib.plugins.git.remote import RemoteGitTagDict

            return RemoteGitTagDict(branch)

        else:

            return LocalGitTagDict(branch)

    def initialize(self, a_bzrdir, name=None, repository=None):

        from bzrlib.plugins.git.dir import LocalGitDir

        if not isinstance(a_bzrdir, LocalGitDir):

            raise errors.IncompatibleFormat(self, a_bzrdir._format)

        if repository is None:

            repository = a_bzrdir.open_repository()

        ref = branch_name_to_ref(name, "HEAD")

        repository._git[ref] = ZERO_SHA

        return LocalGitBranch(a_bzrdir, repository, ref, a_bzrdir._lockfiles)

class GitReadLock(object):

    def __init__(self, unlock):

        self.unlock = unlock

class GitWriteLock(object):

    def __init__(self, unlock):

        self.branch_token = None

        self.unlock = unlock

class GitBranch(ForeignBranch):

    """An adapter to git repositories for bzr Branch objects."""

    @property

    def control_transport(self):

        return self.bzrdir.control_transport

    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):

        self.repository = repository

        self._format = GitBranchFormat()

        self.control_files = lockfiles

        self.bzrdir = bzrdir

        super(GitBranch, self).__init__(repository.get_mapping())

        if tagsdict is not None:

            self.tags = DictTagDict(self, tagsdict)

        self.ref = ref

        self.name = ref_to_branch_name(ref)

        self._head = None

        self.base = bzrdir.root_transport.base

    def _get_checkout_format(self):

        """Return the most suitable metadir for a checkout of this branch.

        Weaves are used if this branch's repository uses weaves.

        """

        return bzrdir.format_registry.make_bzrdir("default")

    def get_child_submit_format(self):

        """Return the preferred format of submissions to this branch."""

        ret = self.get_config().get_user_option("child_submit_format")

        if ret is not None:

            return ret

        return "git"

    def _get_nick(self, local=False, possible_master_transports=None):

        """Find the nick name for this branch.

        :return: Branch nick

        """

        return self.name or "HEAD"

    def _set_nick(self, nick):

        raise NotImplementedError

    nick = property(_get_nick, _set_nick)

    def __repr__(self):

        return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,

            self.ref or "HEAD")

    def generate_revision_history(self, revid, old_revid=None):

        if revid == NULL_REVISION:

            newhead = ZERO_SHA

        else:

            # FIXME: Check that old_revid is in the ancestry of revid

            newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)

        self._set_head(newhead)

    def lock_write(self):

        self.control_files.lock_write()

        return GitWriteLock(self.unlock)

    def get_stacked_on_url(self):

        # Git doesn't do stacking (yet...)

        raise errors.UnstackableBranchFormat(self._format, self.base)

    def get_parent(self):

        """See Branch.get_parent()."""

        # FIXME: Set "origin" url from .git/config ?

        return None

    def set_parent(self, url):

        # FIXME: Set "origin" url in .git/config ?

        pass

    def lock_read(self):

        self.control_files.lock_read()

        return GitReadLock(self.unlock)

    def is_locked(self):

        return self.control_files.is_locked()

    def unlock(self):

        self.control_files.unlock()

    def get_physical_lock_status(self):

        return False

    @needs_read_lock

    def last_revision(self):

        # perhaps should escape this ?

        if self.head is None:

            return revision.NULL_REVISION

        return self.lookup_foreign_revision_id(self.head)

    def _basic_push(self, target, overwrite=False, stop_revision=None):

        return branch.InterBranch.get(self, target)._basic_push(

            overwrite, stop_revision)

    def lookup_foreign_revision_id(self, foreign_revid):

        return self.repository.lookup_foreign_revision_id(foreign_revid,

            self.mapping)

    def lookup_bzr_revision_id(self, revid):

        return self.repository.lookup_bzr_revision_id(

            revid, mapping=self.mapping)

class LocalGitBranch(GitBranch):

    """A local Git branch."""

    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):

        super(LocalGitBranch, self).__init__(bzrdir, repository, ref,

              lockfiles, tagsdict)

        refs = repository._git.get_refs()

        if not (ref in refs.keys() or "HEAD" in refs.keys()):

            raise errors.NotBranchError(self.base)

    def create_checkout(self, to_location, revision_id=None, lightweight=False,

        accelerator_tree=None, hardlink=False):

        if lightweight:

            t = transport.get_transport(to_location)

            t.ensure_base()

            format = self._get_checkout_format()

            checkout = format.initialize_on_transport(t)

            from_branch = branch.BranchReferenceFormat().initialize(checkout,

                self)

            tree = checkout.create_workingtree(revision_id,

                from_branch=from_branch, hardlink=hardlink)

            return tree

        else:

            return self._create_heavyweight_checkout(to_location, revision_id,

                hardlink)

    def _create_heavyweight_checkout(self, to_location, revision_id=None,

                                     hardlink=False):

        """Create a new heavyweight checkout of this branch.

        :param to_location: URL of location to create the new checkout in.

        :param revision_id: Revision that should be the tip of the checkout.

        :param hardlink: Whether to hardlink

        :return: WorkingTree object of checkout.

        """

        checkout_branch = bzrdir.BzrDir.create_branch_convenience(

            to_location, force_new_tree=False)

        checkout = checkout_branch.bzrdir

        checkout_branch.bind(self)

        # pull up to the specified revision_id to set the initial

        # branch tip correctly, and seed it with history.

        checkout_branch.pull(self, stop_revision=revision_id)

        return checkout.create_workingtree(revision_id, hardlink=hardlink)

    def _gen_revision_history(self):

        if self.head is None:

            return []

        ret = list(self.repository.iter_reverse_revision_history(

            self.last_revision()))

        ret.reverse()

        return ret

    def _get_head(self):

        try:

            return self.repository._git.ref(self.ref or "HEAD")

        except KeyError:

            return None

    def set_last_revision_info(self, revno, revid):

        self.set_last_revision(revid)

    def set_last_revision(self, revid):

        (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)

        self.head = newhead

    def _set_head(self, value):

        self._head = value

        self.repository._git.refs[self.ref or "HEAD"] = self._head

        self._clear_cached_state()

    head = property(_get_head, _set_head)

    def get_config(self):

        return GitBranchConfig(self)

    def get_push_location(self):

        """See Branch.get_push_location."""

        push_loc = self.get_config().get_user_option('push_location')

        return push_loc

    def set_push_location(self, location):

        """See Branch.set_push_location."""

        self.get_config().set_user_option('push_location', location,

                                          store=config.STORE_LOCATION)

    def supports_tags(self):

        return True

def _quick_lookup_revno(local_branch, remote_branch, revid):

    assert isinstance(revid, str), "was %r" % revid

    # Try in source branch first, it'll be faster

    try:

        return local_branch.revision_id_to_revno(revid)

    except errors.NoSuchRevision:

        graph = local_branch.repository.get_graph()

        try:

            return graph.find_distance_to_null(revid)

        except errors.GhostRevisionsHaveNoRevno:

            # FIXME: Check using graph.find_distance_to_null() ?

            return remote_branch.revision_id_to_revno(revid)

class GitBranchPullResult(branch.PullResult):

    def __init__(self):

        super(GitBranchPullResult, self).__init__()

        self.new_git_head = None

        self._old_revno = None

        self._new_revno = None

    def report(self, to_file):

        if not is_quiet():

            if self.old_revid == self.new_revid:

                to_file.write('No revisions to pull.\n')

            elif self.new_git_head is not None:

                to_file.write('Now on revision %d (git sha: %s).\n' %

                        (self.new_revno, self.new_git_head))

            else:

                to_file.write('Now on revision %d.\n' % (self.new_revno,))

        self._show_tag_conficts(to_file)

    def _lookup_revno(self, revid):

        return _quick_lookup_revno(self.target_branch, self.source_branch,

                revid)

    def _get_old_revno(self):

        if self._old_revno is not None:

            return self._old_revno

        return self._lookup_revno(self.old_revid)

    def _set_old_revno(self, revno):

        self._old_revno = revno

    old_revno = property(_get_old_revno, _set_old_revno)

    def _get_new_revno(self):

        if self._new_revno is not None:

            return self._new_revno

        return self._lookup_revno(self.new_revid)

    def _set_new_revno(self, revno):

        self._new_revno = revno

    new_revno = property(_get_new_revno, _set_new_revno)

class GitBranchPushResult(branch.BranchPushResult):

    def _lookup_revno(self, revid):

        return _quick_lookup_revno(self.source_branch, self.target_branch,

            revid)

    @property

    def old_revno(self):

        return self._lookup_revno(self.old_revid)

    @property

    def new_revno(self):

        new_original_revno = getattr(self, "new_original_revno", None)

        if new_original_revno:

            return new_original_revno

        if getattr(self, "new_original_revid", None) is not None:

            return self._lookup_revno(self.new_original_revid)

        return self._lookup_revno(self.new_revid)

class InterFromGitBranch(branch.GenericInterBranch):

    """InterBranch implementation that pulls from Git into bzr."""

    @staticmethod

    def _get_branch_formats_to_test():

        try:

            default_format = branch.format_registry.get_default()

        except AttributeError:

            default_format = branch.BranchFormat._default_format

        return [

            (GitBranchFormat(), GitBranchFormat()),

            (GitBranchFormat(), default_format)]

    @classmethod

    def _get_interrepo(self, source, target):

        return _mod_repository.InterRepository.get(source.repository, target.repository)

    @classmethod

    def is_compatible(cls, source, target):

        return (isinstance(source, GitBranch) and

                not isinstance(target, GitBranch) and

                (getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))

    def fetch(self, stop_revision=None, fetch_tags=True):

        self.fetch_objects(stop_revision, fetch_tags=fetch_tags)

    def fetch_objects(self, stop_revision, fetch_tags):

        interrepo = self._get_interrepo(self.source, self.target)

        def determine_wants(heads):

            if self.source.ref is not None and not self.source.ref in heads:

                raise NoSuchRef(self.source.ref, heads.keys())

            if stop_revision is None:

                if self.source.ref is not None:

                    head = heads[self.source.ref]

                else:

                    head = heads["HEAD"]

                self._last_revid = self.source.lookup_foreign_revision_id(head)

            else:

                self._last_revid = stop_revision

            real = interrepo.get_determine_wants_revids(

                [self._last_revid], include_tags=fetch_tags)

            return real(heads)

        pack_hint, head, refs = interrepo.fetch_objects(

            determine_wants, self.source.mapping)

        if (pack_hint is not None and

            self.target.repository._format.pack_compresses):

            self.target.repository.pack(hint=pack_hint)

        return head, refs

    def update_revisions(self, stop_revision=None, overwrite=False,

                         graph=None):

        """See InterBranch.update_revisions()."""

        head, refs = self.fetch_objects(stop_revision, fetch_tags=True)

        if overwrite:

            prev_last_revid = None

        else:

            prev_last_revid = self.target.last_revision()

        self.target.generate_revision_history(self._last_revid,

            prev_last_revid, self.source)

        return head, refs

    def pull(self, overwrite=False, stop_revision=None,

             possible_transports=None, _hook_master=None, run_hooks=True,

             _override_hook_target=None, local=False):

        """See Branch.pull.

        :param _hook_master: Private parameter - set the branch to