~bzr/ubuntu/karmic/bzr-git/bzr-ppa

from bzrlib.foreign import ForeignBranch

 

 

    ret = {}

    for k,v in refs.iteritems():

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

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

    return ret

 

 

 

    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)

    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

            self.tags = DictTagDict(self, tagsdict)

        self.name = name

        self._head = None

 

    def _get_checkout_format(self):

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

 

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

 

            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)

            if self.old_revid == self.new_revid:

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

            else:

                        (self.new_revno, self.new_git_head))

        self._show_tag_conficts(to_file)

 

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

 

    @classmethod

 

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

        graph=None):

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

        self._head = None

        self._last_revid = None

        def determine_wants(heads):

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

            if stop_revision is not None:

                self._last_revid = stop_revision

                    stop_revision)

            else:

                self._head = heads[self.source.name]

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

            result.old_revno, result.old_revid = \

                self.target.last_revision_info()

                graph=graph)

            result.new_git_head = self._head

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

        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.new_git_head = self._head

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

            overwrite)

    @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

                self.source.repository._git.object_store.generate_pack_contents)

        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

 

        possible_transports=None, local=False):

        # This type of branch can't be bound.

        if local:

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