/brz/remove-bazaar

# Copyright (C) 2007,2012 Canonical Ltd

# Copyright (C) 2009-2012 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 __future__ import absolute_import

from cStringIO import StringIO

from collections import defaultdict

from dulwich.objects import (

    ZERO_SHA,

    )

from dulwich.repo import check_ref_format

from ... import (

    branch,

    config,

    controldir,

    errors,

    lock,

    repository as _mod_repository,

    revision,

    tag,

    transport,

    urlutils,

    )

from ...revision import (

    NULL_REVISION,

    )

from ...trace import (

    is_quiet,

    mutter,

    warning,

    )

from .config import (

    GitBranchConfig,

    GitBranchStack,

    )

from .errors import (

    NoPushSupport,

    NoSuchRef,

    )

from .refs import (

    is_tag,

    ref_to_branch_name,

    ref_to_tag_name,

    tag_name_to_ref,

    )

from .unpeel_map import (

    UnpeelMap,

    )

from ...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

        with self.target_branch.lock_read():

            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_container(self):

        raise NotImplementedError(self.get_refs_container)

    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, unpeeled in refs.as_dict().iteritems():

            try:

                tag_name = ref_to_tag_name(k)

            except (ValueError, UnicodeDecodeError):

                continue

            peeled = refs.get_peeled(k)

            if peeled is None:

                peeled = self.repository.controldir._git.object_store.peel_sha(unpeeled).id

            assert type(tag_name) is unicode

            yield (tag_name, peeled, unpeeled,

                   self.branch.lookup_foreign_revision_id(peeled))

    def _merge_to_remote_git(self, target_repo, new_refs, overwrite=False):

        updates = {}

        conflicts = []

        def get_changed_refs(old_refs):

            ret = dict(old_refs)

            for k, v in new_refs.iteritems():

                if not is_tag(k):

                    continue

                name = ref_to_tag_name(k)

                if old_refs.get(k) == v:

                    pass

                elif overwrite or not k in old_refs:

                    ret[k] = v

                    updates[name] = target_repo.lookup_foreign_revision_id(v)

                else:

                    conflicts.append((name, v, old_refs[k]))

            return ret

        target_repo.controldir.send_pack(get_changed_refs, lambda have, want: [])

        return updates, conflicts

    def _merge_to_local_git(self, target_repo, refs, overwrite=False):

        conflicts = []

        updates = {}

        for k, unpeeled in refs.as_dict().iteritems():

            if not is_tag(k):

                continue

            name = ref_to_tag_name(k)

            peeled = self.repository.controldir.get_peeled(k)

            if target_repo._git.refs.get(k) == unpeeled:

                pass

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

                target_repo._git.refs[k] = unpeeled or peeled

                updates[name] = target_repo.lookup_foreign_revision_id(peeled)

            else:

                conflicts.append((name, peeled, target_repo._git.refs[k]))

        return updates, conflicts

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

        target_repo = to_tags.repository

        if self.repository.has_same_location(target_repo):

            return {}, []

        if getattr(target_repo, "_git", None):

            return self._merge_to_local_git(target_repo, refs, overwrite)

        else:

            return self._merge_to_remote_git(target_repo, refs, overwrite)

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

        unpeeled_map = defaultdict(set)

        conflicts = []

        updates = {}

        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 result.get(n) == bzr_revid:

                pass

            elif n not in result or overwrite:

                result[n] = bzr_revid

                updates[n] = bzr_revid

            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 updates, 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_container()

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

            updates, conflicts = self._merge_to_non_git(to_tags, source_refs,

                                              overwrite=overwrite)

            if master is not None:

                extra_updates, extra_conflicts = self.merge_to(

                    master.tags, overwrite=overwrite,

                                           source_refs=source_refs,

                                           ignore_master=ignore_master)

                updates.update(extra_updates)

                conflicts += extra_conflicts

            return updates, conflicts

    def get_tag_dict(self):

        ret = {}

        refs = self.get_refs_container()

        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.controldir._git.refs

    def get_refs_container(self):

        return self.refs

    def _set_tag_dict(self, to_dict):

        extra = set(self.refs.allkeys())

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

        try:

            git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)

        except errors.NoSuchRevision:

            raise errors.GhostTagsNotSupported(self)

        self.refs[tag_name_to_ref(name)] = git_sha

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 GitSymrefBranchFormat(branch.BranchFormat):

    def get_format_description(self):

        return 'Git Symbolic Reference Branch'

    def network_name(self):

        return "git"

    def get_reference(self, controldir, name=None):

        return controldir.get_branch_reference(name)

    def set_reference(self, controldir, name, target):

        return controldir.set_branch_reference(target, name)

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

    def supports_tags_referencing_ghosts(self):

        return False

    def tags_are_versioned(self):

        return False

    @property

    def _matchingcontroldir(self):

        from .dir import LocalGitControlDirFormat

        return LocalGitControlDirFormat()

    def get_foreign_tests_branch_factory(self):

        from .tests.test_branch import ForeignTestsBranchFactory

        return ForeignTestsBranchFactory()

    def make_tags(self, branch):

        try:

            return branch.tags

        except AttributeError:

            pass

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

            from .remote import RemoteGitTagDict

            return RemoteGitTagDict(branch)

        else:

            return LocalGitTagDict(branch)

    def initialize(self, a_controldir, name=None, repository=None,

                   append_revisions_only=None):

        from .dir import LocalGitDir

        if not isinstance(a_controldir, LocalGitDir):

            raise errors.IncompatibleFormat(self, a_controldir._format)

        return a_controldir.create_branch(repository=repository, name=name,

            append_revisions_only=append_revisions_only)

class GitBranch(ForeignBranch):

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

    @property

    def control_transport(self):

        return self.controldir.control_transport

    def __init__(self, controldir, repository, ref):

        self.base = controldir.root_transport.base

        self.repository = repository

        self._format = GitBranchFormat()

        self.controldir = controldir

        self._lock_mode = None

        self._lock_count = 0

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

        self.ref = ref

        try:

            self.name = ref_to_branch_name(ref)

        except ValueError:

            self.name = None

        self._head = None

    def _get_checkout_format(self, lightweight=False):

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

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

        """

        return controldir.format_registry.make_controldir("default")

    def get_child_submit_format(self):

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

        ret = self.get_config_stack().get("child_submit_format")

        if ret is not None:

            return ret

        return "git"

    def get_config(self):

        return GitBranchConfig(self)

    def get_config_stack(self):

        return GitBranchStack(self)

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

        """Find the nick name for this branch.

        :return: Branch nick

        """

        cs = self.repository._git.get_config_stack()

        try:

            return cs.get(("branch", self.name), "nick")

        except KeyError:

            pass

        return self.name.encode('utf-8') or "HEAD"

    def _set_nick(self, nick):

        cf = self.repository._git.get_config()

        cf.set(("branch", self.name), "nick", nick)

        f = StringIO()

        cf.write_to_file(f)

        self.controldir.control_transport.put_bytes('config', f.getvalue())

    nick = property(_get_nick, _set_nick)

    def __repr__(self):

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

            self.name)

    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.repository.lookup_bzr_revision_id(revid)

            if self.mapping is None:

                raise AssertionError

        self._set_head(newhead)

    def lock_write(self, token=None):

        if token is not None:

            raise errors.TokenLockingNotSupported(self)

        if self._lock_mode:

            if self._lock_mode == 'r':

                raise errors.ReadOnlyError(self)

            self._lock_count += 1

        else:

            self._lock_mode = 'w'

            self._lock_count = 1

        self.repository.lock_write()

        return lock.LogicalLockResult(self.unlock)

    def leave_lock_in_place(self):

        raise NotImplementedError(self.leave_lock_in_place)

    def dont_leave_lock_in_place(self):

        raise NotImplementedError(self.dont_leave_lock_in_place)

    def get_stacked_on_url(self):

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

        raise branch.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 break_lock(self):

        raise NotImplementedError(self.break_lock)

    def lock_read(self):

        if self._lock_mode:

            assert self._lock_mode in ('r', 'w')

            self._lock_count += 1

        else:

            self._lock_mode = 'r'

            self._lock_count = 1

        self.repository.lock_read()

        return lock.LogicalLockResult(self.unlock)

    def peek_lock_mode(self):

        return self._lock_mode

    def is_locked(self):

        return (self._lock_mode is not None)

    def unlock(self):

        """See Branch.unlock()."""

        self._lock_count -= 1

        if self._lock_count == 0:

            self._lock_mode = None

            self._clear_cached_state()

        self.repository.unlock()

    def get_physical_lock_status(self):

        return False

    def last_revision(self):

        with self.lock_read():

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

    def get_unshelver(self, tree):

        raise errors.StoringUncommittedNotSupported(self)

class LocalGitBranch(GitBranch):

    """A local Git branch."""

    def __init__(self, controldir, repository, ref):

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

        refs = controldir.get_refs_container()

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

            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(lightweight=True)

            checkout = format.initialize_on_transport(t)

            from breezy.bzr.branch import BranchReferenceFormat

            from_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 = controldir.ControlDir.create_branch_convenience(

            to_location, force_new_tree=False,

            format=self._get_checkout_format(lightweight=False))

        checkout = checkout_branch.controldir

        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 fetch(self, from_branch, last_revision=None, limit=None):

        return branch.InterBranch.get(from_branch, self).fetch(

            stop_revision=last_revision, limit=limit)

    def _gen_revision_history(self):

        if self.head is None:

            return []

        graph = self.repository.get_graph()

        ret = list(graph.iter_lefthand_ancestry(self.last_revision(),

            (revision.NULL_REVISION, )))

        ret.reverse()

        return ret

    def _get_head(self):

        try:

            return self.repository._git.refs[self.ref or "HEAD"]

        except KeyError:

            return None

    def _read_last_revision_info(self):

        last_revid = self.last_revision()

        graph = self.repository.get_graph()

        revno = graph.find_distance_to_null(last_revid,

            [(revision.NULL_REVISION, 0)])

        return revno, last_revid

    def set_last_revision_info(self, revno, revision_id):

        self.set_last_revision(revision_id)

        self._last_revision_info_cache = revno, revision_id

    def set_last_revision(self, revid):

        if not revid or not isinstance(revid, basestring):

            raise errors.InvalidRevisionId(revision_id=revid, branch=self)

        if revid == NULL_REVISION:

            newhead = ZERO_SHA

        else:

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

            if self.mapping is None:

                raise AssertionError

        self._set_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_push_location(self):

        """See Branch.get_push_location."""

        push_loc = self.get_config_stack().get('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 store_uncommitted(self, creator):

        raise errors.StoringUncommittedNotSupported(self)

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

    local_branch.lock_read()

    try:

        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,

                    [(revision.NULL_REVISION, 0)])

            except errors.GhostRevisionsHaveNoRevno:

                # FIXME: Check using graph.find_distance_to_null() ?

                remote_branch.lock_read()

                try:

                    return remote_branch.revision_id_to_revno(revid)

                finally: