/brz/remove-bazaar

 

from bzrlib import (

    debug,

    osutils,

    trace,

    ui,

    topo_sort,

    )

from bzrlib.versionedfile import (

    )

 

from bzrlib.plugins.git.mapping import (

    )

from bzrlib.plugins.git.object_store import (

    BazaarObjectStore,

    )

from bzrlib.plugins.git.remote import (

    RemoteGitRepository,

    )

 

 

    """Import a git blob object into a bzr repository.

 

    :param texts: VersionedFiles to add to

        base_sha = None

    else:

        try:

        except KeyError:

            base_sha = None

        else:

        ie.revision = revision_id

        assert file_id is not None

        assert ie.revision is not None

    invdelta = []

    if base_ie is not None:

        old_path = base_inv.id2path(file_id)

 

 

def import_git_submodule(texts, mapping, path, hexsha, base_inv, base_ie,

    file_id = mapping.generate_file_id(path)

    ie = TreeReference(file_id, urlutils.basename(path.decode("utf-8")),

        parent_id)

            base_ie.reference_revision == ie.reference_revision):

            ie.revision = base_ie.revision

    ie.reference_revision = mapping.revision_id_foreign_to_bzr(hexsha)

    invdelta = [(oldpath, path, file_id, ie)]

    return invdelta, {}, {}

 

    return ret

 

 

    """Import a git tree object into a bzr repository.

 

    :param texts: VersionedFiles object to add to

    if base_ie is None:

        # Newly appeared here

        ie.revision = revision_id

        invdelta.append((None, path, file_id, ie))

    else:

        # See if this has changed at all

        try:

            pass

        else:

            if base_sha == hexsha:

                return [], {}, []

        if base_ie.kind != "directory":

            ie.revision = revision_id

            invdelta.append((base_inv.id2path(ie.file_id), path, ie.file_id, ie))

    if base_ie is not None and base_ie.kind == "directory":

        base_children = base_ie.children

    # Remember for next time

    existing_children = set()

    child_modes = {}

    tree = lookup_object(hexsha)

    for mode, name, child_hexsha in tree.entries():

        basename = name.decode("utf-8")

        if stat.S_ISDIR(mode):

            subinvdelta, grandchildmodes, subshamap = import_git_tree(

                    texts, mapping, child_path, child_hexsha, base_inv,

                    allow_submodules=allow_submodules)

        elif S_ISGITLINK(mode): # submodule

            if not allow_submodules:

                raise SubmodulesRequireSubtrees()

            subinvdelta, grandchildmodes, subshamap = import_git_submodule(

                    texts, mapping, child_path, child_hexsha, base_inv, base_children.get(basename),

        else:

            subinvdelta, subshamap = import_git_blob(texts, mapping,

                    mode_is_executable(mode), stat.S_ISLNK(mode))

        if mode not in (stat.S_IFDIR, DEFAULT_FILE_MODE,

                        stat.S_IFLNK, DEFAULT_FILE_MODE|0111):

            child_modes[child_path] = mode

    if base_ie is not None and base_ie.kind == "directory":

        invdelta.extend(remove_disappeared_children(base_inv.id2path(file_id),

            base_children, existing_children))

    return invdelta, child_modes, shamap

 

 

def import_git_commit(repo, mapping, head, lookup_object,

                      target_git_object_retriever, parent_invs_cache):

    o = lookup_object(head)

    # We have to do this here, since we have to walk the tree and

    # we need to make sure to import the blobs / trees with the right

    # path; this may involve adding them more than once.

    if parent_invs == []:

        base_inv = Inventory(root_id=None)

        base_ie = None

    else:

        base_inv = parent_invs[0]

        base_ie = base_inv.root

    inv_delta, unusual_modes, shamap = import_git_tree(repo.texts,

            allow_submodules=getattr(repo._format, "supports_tree_reference", False))

    if unusual_modes != {}:

        for path, mode in unusual_modes.iteritems():

            warn_unusual_mode(rev.foreign_revid, path, mode)

    rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,

              inv_delta, rev.revision_id, rev.parent_ids,

              base_inv)

    repo.add_revision(rev.revision_id, rev)

    if "verify" in debug.debug_flags:

        new_unusual_modes = mapping.export_unusual_file_modes(rev)

        if new_unusual_modes != unusual_modes:

            raise AssertionError("unusual modes don't match: %r != %r" % (unusual_modes, new_unusual_modes))

        objs = inventory_to_tree_and_blobs(inv, repo.texts, mapping, unusual_modes)

            assert path is not None

    """Import a set of git objects into a bzr repository.

 

    :param repo: Target Bazaar repository

    :param mapping: Mapping to use

    :param object_iter: Iterator over Git objects.

    """

    def lookup_object(sha):

        try:

            return object_iter[sha]

    # TODO: a more (memory-)efficient implementation of this

    graph = []

    checked = set()

    # Find and convert commit objects

    while heads:

        if pb is not None:

        try:

            o = lookup_object(head)

        except KeyError:

            continue

        if isinstance(o, Commit):

            rev = mapping.import_commit(o)

                continue

            squash_revision(repo, rev)

            graph.append((o.id, o.parents))

            heads.extend([p for p in o.parents if p not in checked])

        elif isinstance(o, Tag):

        else:

            trace.warning("Unable to import head object %r" % o)

        checked.add(o.id)

    batch_size = 100

    revision_ids = topo_sort(graph)

    pack_hints = []

    for offset in range(0, len(revision_ids), batch_size):

        repo.start_write_group()

        try:

                import_git_commit(repo, mapping, head, lookup_object,

                                  target_git_object_retriever,

                                  parent_invs_cache)

        except:

            repo.abort_write_group()

            raise

            hint = repo.commit_write_group()

            if hint is not None:

                pack_hints.extend(hint)

 

 

class InterGitRepository(InterRepository):

        """See InterRepository.copy_content."""

        self.fetch(revision_id, pb, find_ghosts=False)

 

 

 

class InterGitNonGitRepository(InterGitRepository):

            else:

                ret = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in interesting_heads if revid not in (None, NULL_REVISION)]

            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]

        if pack_hint is not None and self.target._format.pack_compresses:

            self.target.pack(hint=pack_hint)

        if interesting_heads is not None:

        map(all_parents.update, parent_map.itervalues())

        return set(all_revs) - all_parents

 

        def progress(text):

            report_git_progress(pb, text)

        store = BazaarObjectStore(self.target, mapping)

                            record_determine_wants, graph_walker,

                            store.get_raw, progress)

                return import_git_objects(self.target, mapping,

            finally:

                if create_pb:

                    create_pb.finished()

    """InterRepository that copies revisions from a local Git into a non-Git

    repository."""

 

        wants = determine_wants(self.source._git.get_refs())

        create_pb = None

        if pb is None:

            self.target.lock_write()

            try:

                return import_git_objects(self.target, mapping,

            finally:

                self.target.unlock()

        finally:

            determine_wants = r.object_store.determine_wants_all

        else:

            determine_wants = lambda x: [y for y in args if not y in r.object_store]

 

 

    @staticmethod