/brz/remove-bazaar

from bzrlib.revisiontree import (

    RevisionTree,

    )

from bzrlib.tsort import (

    topo_sort,

    )

    else:

        cls = InventoryFile

    ie = cls(file_id, name.decode("utf-8"), parent_id)

    if base_hexsha == hexsha and mode_kind(base_mode) == mode_kind(mode):

        base_ie = base_inv[base_inv.path2id(path)]

        ie.text_size = base_ie.text_size

        ie.text_sha1 = base_ie.text_sha1

        if ie.executable == base_ie.executable:

            ie.revision = base_ie.revision

        else:

        if ie.kind == "symlink":

            ie.revision = None

            ie.symlink_target = blob.data

        else:

            ie.text_size = sum(imap(len, blob.chunked))

            ie.text_sha1 = osutils.sha_strings(blob.chunked)

                tuple(parent_keys), ie.text_sha1, chunks)])

    invdelta = []

    if base_hexsha is not None:

        if stat.S_ISDIR(base_mode):

            invdelta.extend(remove_disappeared_children(base_inv, old_path,

                lookup_object(base_hexsha), [], lookup_object))

    else:

        old_path = None

    if base_hexsha != hexsha:

    return invdelta

 

 

 

def remove_disappeared_children(base_inv, path, base_tree, existing_children,

        lookup_object):

    ret = []

    for name, mode, hexsha in base_tree.iteritems():

        if name in existing_children:

            continue

        c_path = posixpath.join(path, name.decode("utf-8"))

        if stat.S_ISDIR(mode):

            ret.extend(remove_disappeared_children(

                base_inv, c_path, lookup_object(hexsha), [], lookup_object))

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

 

    :param texts: VersionedFiles object to add to

    :param tree: A git tree object

    :param base_inv: Base inventory against which to return inventory delta

    :return: Inventory delta for this subtree

    """

    if base_hexsha == hexsha and base_mode == mode:

        # If nothing has changed since the base revision, we're done

        return [], {}

        old_path = None # Newly appeared here

    else:

        base_tree = lookup_object(base_hexsha)

    if base_tree is None or type(base_tree) is not Tree:

        ie.revision = revision_id

        texts.insert_record_stream([

            ChunkedContentFactory((ie.file_id, ie.revision), (), None, [])])

    # Remember for next time

            child_modes[child_path] = child_mode

    # Remove any children that have disappeared

    if base_tree is not None and type(base_tree) is Tree:

            base_tree, existing_children, lookup_object))

    return invdelta, child_modes

 

 

        raise AssertionError("unusual modes don't match: %r != %r" % (

            unusual_modes, new_unusual_modes))

    # Verify that we can reconstruct the commit properly

    if rec_o != o:

        raise AssertionError("Reconstructed commit differs: %r != %r" % (

            rec_o, o))

def import_git_commit(repo, mapping, head, lookup_object,

                      target_git_object_retriever, trees_cache):

    o = lookup_object(head)

            lambda x: target_git_object_retriever.lookup_git_sha(x)[1][0])

    # 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

        base_tree = lookup_object(o.parents[0]).tree

        base_mode = stat.S_IFDIR

    store_updater = target_git_object_retriever._get_updater(rev)

    inv_delta, unusual_modes = import_git_tree(repo.texts,

            None, rev.revision_id, [p.inventory for p in parent_trees],

            lookup_object, (base_mode, stat.S_IFDIR), store_updater,

            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)

        basis_id = NULL_REVISION

        base_inv = None

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

    ret_tree = RevisionTree(repo, inv, rev.revision_id)

    trees_cache.add(ret_tree)

    repo.add_revision(rev.revision_id, rev)

        except KeyError:

            continue

        if isinstance(o, Commit):

                continue

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

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

        """See InterRepository.copy_content."""

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

 

 

class InterGitNonGitRepository(InterGitRepository):

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

    repository."""

 

              mapping=None, fetch_spec=None):

        if mapping is None:

            mapping = self.source.get_mapping()

            interesting_heads = fetch_spec.heads

        else:

            interesting_heads = None

        def determine_wants(refs):

            if interesting_heads is None:

                ret = [sha for (ref, sha) in refs.iteritems() if not ref.endswith("^{}")]

            else:

                ret = [self.source.lookup_bzr_revision_id(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(self.source.lookup_foreign_revision_id(rev))]

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

            self.target.pack(hint=pack_hint)

 

 

_GIT_PROGRESS_RE = re.compile(r"(.*?): +(\d+)% \((\d+)/(\d+)\)")

        pb.update(text, 0, 0)

 

 

class InterRemoteGitNonGitRepository(InterGitNonGitRepository):

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

    repository."""

        return set(all_revs) - all_parents

 

    def fetch_objects(self, determine_wants, mapping, pb=None, limit=None):

        def progress(text):

            report_git_progress(pb, text)

        store = BazaarObjectStore(self.target, mapping)

            heads = self.get_target_heads()

            graph_walker = store.get_graph_walker(

                    [store._lookup_revision_sha1(head) for head in heads])

 

            create_pb = None

            if pb is None:

                create_pb = pb = ui.ui_factory.nested_progress_bar()

            try:

            finally:

                if create_pb:

                    create_pb.finished()

    repository."""

 

    def fetch_objects(self, determine_wants, mapping, pb=None, limit=None):

        create_pb = None

        if pb is None:

            create_pb = pb = ui.ui_factory.nested_progress_bar()

        try:

            self.target.lock_write()

            try:

                    self.source._git.object_store,

                    target_git_object_retriever, wants, pb, limit)

            finally:

                self.target.unlock()

        finally:

        graphwalker = self.target._git.get_graph_walker()

        if (isinstance(self.source, LocalGitRepository) and

            isinstance(self.target, LocalGitRepository)):

                progress)

        elif (isinstance(self.source, LocalGitRepository) and

              isinstance(self.target, RemoteGitRepository)):

            raise NotImplementedError

              isinstance(self.target, LocalGitRepository)):

            f, commit = self.target._git.object_store.add_thin_pack()

            try:

                commit()

            except:

                f.close()

                raise

        else:

            raise AssertionError

 

              mapping=None, fetch_spec=None, branches=None):

        if mapping is None:

            mapping = self.source.get_mapping()

            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

    def is_compatible(source, target):