/brz/remove-bazaar

    bzrdir,

    config,

    errors,

    repository,

    revision,

    tag,

    NoSuchRef,

    )

 

    ret = {}

    for k,v in refs.iteritems():

        if k.startswith("refs/tags/") and not k.endswith("^{}"):

            v = refs.get(k+"^{}", v)

    return ret

 

 

class GitPullResult(branch.PullResult):

 

    def _lookup_revno(self, revid):

 

    def get_tag_dict(self):

        ret = {}

            while isinstance(obj, Tag):

                v = obj.object[1]

            if not isinstance(obj, Commit):

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

                       "ignoring", k, obj)

            ret[k] = self.branch.mapping.revision_id_foreign_to_bzr(v)

        return ret

 

    def set_tag(self, name, revid):

        self.repository._git.refs["refs/tags/%s" % name], _ = \

            self.branch.mapping.revision_id_bzr_to_foreign(revid)

 

 

class GitBranchFormat(branch.BranchFormat):

 

    def get_format_description(self):

        return 'Git Branch'

 

    def supports_tags(self):

        return True

 

    def make_tags(self, branch):

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

            from bzrlib.plugins.git.remote import RemoteGitTagDict

class GitBranch(ForeignBranch):

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

 

        self.repository = repository

        self._format = GitBranchFormat()

        self.control_files = lockfiles

        self.bzrdir = bzrdir

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

        self._head = None

 

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

        """Find the nick name for this branch.

    nick = property(_get_nick, _set_nick)

 

    def __repr__(self):

 

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

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

 

    def get_stacked_on_url(self):

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

 

    def get_parent(self):

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

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

            overwrite, stop_revision)

 

class LocalGitBranch(GitBranch):

    """A local Git branch."""

 

 

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

        accelerator_tree=None, hardlink=False):

            t.ensure_base()

            format = self._get_checkout_format()

            checkout = format.initialize_on_transport(t)

                self)

            tree = checkout.create_workingtree(revision_id,

                from_branch=from_branch, hardlink=hardlink)

            return self._create_heavyweight_checkout(to_location, revision_id,

            hardlink)

 

                                     hardlink=False):

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

 

            to_location, force_new_tree=False, format=get_rich_root_format())

        checkout = checkout_branch.bzrdir

        checkout_branch.bind(self)

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

        try:

        except KeyError:

            return None

 

 

    def _set_head(self, value):

        self._head = value

        self._clear_cached_state()

 

    head = property(_get_head, _set_head)

        if not is_quiet():

            if self.old_revid == self.new_revid:

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

                        (self.new_revno, self.new_git_head))

        self._show_tag_conficts(to_file)

 

 

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

 

    @classmethod

        def determine_wants(heads):

            if stop_revision is not None:

                self._last_revid = stop_revision

                    stop_revision)

            else:

            if self.target.repository.has_revision(self._last_revid):

                return []

        if overwrite:

            prev_last_revid = None

        else:

            prev_last_revid = self.target.last_revision()

 

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

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

        """See Branch.pull.

 

        :param _hook_master: Private parameter - set the branch to

            so it should not run its hooks.

        :param _override_hook_target: Private parameter - set the branch to be

            supplied as the target_branch to pull hooks.

        """

        # This type of branch can't be bound.

        if local:

            # We assume that during 'pull' the target repository is closer than

            # the source one.

            graph = self.target.repository.get_graph(self.source.repository)

                self.target.last_revision_info()

            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

                overwrite)

            if _hook_master:

                result.master_branch = _hook_master

                result.local_branch = result.target_branch

        result.target_branch = self.target

        graph = self.target.repository.get_graph(self.source.repository)

        result.old_revno, result.old_revid = self.target.last_revision_info()

        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

            overwrite)

        result.new_revno, result.new_revid = self.target.last_revision_info()

    @classmethod

    def is_compatible(self, source, target):

        from bzrlib.plugins.git.remote import RemoteGitBranch

                isinstance(target, RemoteGitBranch))

 

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

        # FIXME: Check for diverged branches

        def get_changed_refs(old_refs):

            result.old_revid = self.target.mapping.revision_id_foreign_to_bzr(old_refs.get("refs/heads/master", "0" * 40))

            result.new_revid = stop_revision

            for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():

                refs["refs/tags/%s" % name] = sha

            return refs

        return result

 

 

    @classmethod

    def is_compatible(self, source, target):

        from bzrlib.plugins.git.remote import RemoteGitBranch

                isinstance(target, LocalGitBranch))

 

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

        return result

 

    def update_tags(self, refs):

            self.target.tags.set_tag(name, revid)

 

    def update_refs(self, stop_revision=None):

            self.target.repository)

        if stop_revision is None:

            refs = interrepo.fetch_refs(branches=["HEAD"])

            refs = interrepo.fetch_refs(revision_id=stop_revision)

        return refs, stop_revision

 

        # This type of branch can't be bound.

        if local:

            raise errors.LocalRequiresBoundBranch()

        result.new_revid = self.target.last_revision()

        return result

 

class InterToGitBranch(branch.InterBranch):

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

 

    @classmethod

    def is_compatible(self, source, target):

                isinstance(target, GitBranch))

 

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

        raise NoPushSupport()

 

             _override_hook_source_branch=None):

        raise NoPushSupport()

 

        result = GitBranchPushResult()

        result.source_branch = self.source

        result.target_branch = self.target

        if stop_revision is None:

            stop_revision = self.source.last_revision()

        # FIXME: Check for diverged branches