/brz/remove-bazaar

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 

from dulwich.objects import (

    Commit,

    Tag,

    )

from dulwich.object_store import (

    tree_lookup_path,

    )

import stat

 

from bzrlib import (

    urlutils,

    )

from bzrlib.errors import (

    NoSuchId,

    )

from bzrlib.inventory import (

    Inventory,

    DEFAULT_FILE_MODE,

    inventory_to_tree_and_blobs,

    mode_is_executable,

    warn_unusual_mode,

    )

from bzrlib.plugins.git.object_store import (

    )

 

 

    revision_id, parent_invs, shagitmap, lookup_object, executable, symlink):

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

 

    # We just have to hope this is indeed utf-8:

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

    ie.executable = executable

    # See if this has changed at all

        base_sha = None

    else:

        try:

        except KeyError:

            base_sha = None

        else:

        ie.text_size = base_ie.text_size

        ie.text_sha1 = base_ie.text_sha1

        ie.symlink_target = base_ie.symlink_target

    else:

        blob = lookup_object(hexsha)

        if ie.kind == "symlink":

            ie.symlink_target = blob.data

            ie.text_size = None

            ie.text_sha1 = None

                pie = pinv[file_id]

            except NoSuchId:

                continue

            # found a revision in one of the parents to use

            ie.revision = pie.revision

            break

        shamap = [(hexsha, "blob", (ie.file_id, ie.revision))]

    else:

        shamap = []

        old_path = base_inv.id2path(file_id)

    else:

        old_path = None

    revision_id, parent_invs, shagitmap, lookup_object):

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

 

    # We just have to hope this is indeed utf-8:

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

        parent_id)

        # Newly appeared here

        ie.revision = revision_id

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

    else:

        # See if this has changed at all

        try:

        except KeyError:

            pass

        else:

            if base_sha == hexsha:

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

                return [], {}, []

    # Remember for next time

    existing_children = set()

    child_modes = {}

        existing_children.add(basename)

        child_path = osutils.pathjoin(path, name)

        if stat.S_ISDIR(mode):

            invdelta.extend(subinvdelta)

            child_modes.update(grandchildmodes)

            shamap.extend(subshamap)

        else:

            subinvdelta, subshamap = import_git_blob(texts, mapping, 

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

            invdelta.extend(subinvdelta)

            shamap.extend(subshamap)

                        stat.S_IFLNK, DEFAULT_FILE_MODE|0111):

            child_modes[child_path] = mode

    # Remove any children that have disappeared

    shamap.append((hexsha, "tree", (file_id, revision_id)))

    return invdelta, child_modes, shamap

 

            rev = mapping.import_commit(o)

            if repo.has_revision(rev.revision_id):

                continue

            root_trees[rev.revision_id] = o.tree

            revisions[rev.revision_id] = rev

            graph.append((rev.revision_id, rev.parent_ids))

                parent_invs_cache[parent_id] = parent_inv

        if parent_invs == []:

            base_inv = Inventory(root_id=None)

        else:

            base_inv = parent_invs[0]

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

                parent_invs, target_git_object_retriever._idmap, lookup_object)

        target_git_object_retriever._idmap.add_entries(shamap)

        if unusual_modes != {}:

            for path, mode in unusual_modes.iteritems():

                warn_unusual_mode(rev.foreign_revid, path, mode)

        try:

            basis_id = rev.parent_ids[0]

        except IndexError:

        parent_invs_cache[rev.revision_id] = inv

        repo.add_revision(rev.revision_id, rev)

        if "verify" in debug.debug_flags:

            for sha1, newobj, path in objs:

                assert path is not None

                oldobj = tree_lookup_path(lookup_object, root_trees[revid], path)

 

    target_git_object_retriever._idmap.commit()

 

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

        return self._refs

 

 

class InterRemoteGitNonGitRepository(InterGitNonGitRepository):

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

    repository."""

 

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

        def progress(text):

        store = BazaarObjectStore(self.target, mapping)

        self.target.lock_write()

        try:

            graph_walker = store.get_graph_walker(

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

            recorded_wants = []

                    import_git_objects(self.target, mapping, objects_iter, 

                            store, recorded_wants, pb)

                finally:

            finally:

                if create_pb:

                    create_pb.finished()

                            self.source._git.object_store, 

                            target_git_object_retriever, wants, pb)

                finally:

            finally:

                self.target.unlock()

        finally: