/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to mapping.py

Fix branch cloning.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mapping.py
1
1
# Copyright (C) 2007 Canonical Ltd
2
 
# Copyright (C) 2008-2009 Jelmer Vernooij <jelmer@samba.org>
3
 
# Copyright (C) 2008 John Carr
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
18
16
 
19
17
"""Converters, etc for going between Bazaar and Git ids."""
20
18
 
21
 
from bzrlib import errors, foreign, urlutils
 
19
from bzrlib import errors, foreign
22
20
from bzrlib.inventory import ROOT_ID
23
21
from bzrlib.foreign import (
24
 
        ForeignVcs, 
25
 
        VcsMappingRegistry, 
26
22
        ForeignRevision,
27
23
        )
28
24
 
 
25
 
29
26
def escape_file_id(file_id):
30
27
    return file_id.replace('_', '__').replace(' ', '_s')
31
28
 
38
35
    """Class that maps between Git and Bazaar semantics."""
39
36
    experimental = False
40
37
 
41
 
    def __init__(self):
42
 
        super(BzrGitMapping, self).__init__(foreign_git)
43
 
 
44
 
    def __eq__(self, other):
45
 
        return type(self) == type(other) and self.revid_prefix == other.revid_prefix
46
 
 
47
 
    @classmethod
48
 
    def revision_id_foreign_to_bzr(cls, git_rev_id):
 
38
    def revision_id_foreign_to_bzr(self, git_rev_id):
49
39
        """Convert a git revision id handle to a Bazaar revision id."""
50
 
        return "%s:%s" % (cls.revid_prefix, git_rev_id)
 
40
        return "%s:%s" % (self.revid_prefix, git_rev_id)
51
41
 
52
 
    @classmethod
53
 
    def revision_id_bzr_to_foreign(cls, bzr_rev_id):
 
42
    def revision_id_bzr_to_foreign(self, bzr_rev_id):
54
43
        """Convert a Bazaar revision id to a git revision id handle."""
55
 
        if not bzr_rev_id.startswith("%s:" % cls.revid_prefix):
56
 
            raise errors.InvalidRevisionId(bzr_rev_id, cls)
57
 
        return bzr_rev_id[len(cls.revid_prefix)+1:], cls()
 
44
        if not bzr_rev_id.startswith("%s:" % self.revid_prefix):
 
45
            raise errors.InvalidRevisionId(bzr_rev_id, self)
 
46
        return bzr_rev_id[len(self.revid_prefix)+1:]
 
47
 
 
48
    def show_foreign_revid(self, foreign_revid):
 
49
        return { "git commit": foreign_revid }
58
50
 
59
51
    def generate_file_id(self, path):
60
52
        if path == "":
79
71
        return rev
80
72
 
81
73
 
82
 
class BzrGitMappingv1(BzrGitMapping):
83
 
    revid_prefix = 'git-v1'
84
 
    experimental = False
85
 
 
86
 
 
87
 
class BzrGitMappingExperimental(BzrGitMappingv1):
 
74
class BzrGitMappingExperimental(BzrGitMapping):
88
75
    revid_prefix = 'git-experimental'
89
76
    experimental = True
90
77
 
91
78
 
92
 
class GitMappingRegistry(VcsMappingRegistry):
93
 
 
94
 
    def revision_id_bzr_to_foreign(self, bzr_revid):
95
 
        if not bzr_revid.startswith("git-"):
96
 
            raise errors.InvalidRevisionId(bzr_revid, None)
97
 
        (mapping_version, git_sha) = bzr_revid.split(":", 1)
98
 
        mapping = self.get(mapping_version)
99
 
        return mapping.revision_id_bzr_to_foreign(bzr_revid)
100
 
 
101
 
    parse_revision_id = revision_id_bzr_to_foreign
102
 
 
103
 
 
104
 
mapping_registry = GitMappingRegistry()
105
 
mapping_registry.register_lazy('git-v1', "bzrlib.plugins.git.mapping",
106
 
                                   "BzrGitMappingv1")
107
 
mapping_registry.register_lazy('git-experimental', "bzrlib.plugins.git.mapping",
108
 
                                   "BzrGitMappingExperimental")
109
 
 
110
 
 
111
 
class ForeignGit(ForeignVcs):
112
 
    """Foreign Git."""
113
 
 
114
 
    def __init__(self):
115
 
        super(ForeignGit, self).__init__(mapping_registry)
116
 
 
117
 
    @classmethod
118
 
    def show_foreign_revid(cls, foreign_revid):
119
 
        return { "git commit": foreign_revid }
120
 
 
121
 
 
122
 
foreign_git = ForeignGit()
123
 
default_mapping = BzrGitMappingv1()
124
 
 
125
 
 
126
 
def inventory_to_tree_and_blobs(repo, mapping, revision_id):
127
 
    from dulwich.objects import Tree, Blob
128
 
    from bzrlib.inventory import InventoryDirectory, InventoryFile
129
 
    import stat
130
 
    stack = []
131
 
    cur = ""
132
 
    tree = Tree()
133
 
 
134
 
    inv = repo.get_inventory(revision_id)
135
 
 
136
 
    # stack contains the set of trees that we haven't 
137
 
    # finished constructing
138
 
 
139
 
    for path, entry in inv.iter_entries():
140
 
        while stack and not path.startswith(cur):
141
 
            tree.serialize()
142
 
            sha = tree.sha().hexdigest()
143
 
            yield sha, tree, cur
144
 
            t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
145
 
            cur, tree = stack.pop()
146
 
            tree.add(*t)
147
 
 
148
 
        if type(entry) == InventoryDirectory:
149
 
            stack.append((cur, tree))
150
 
            cur = path
151
 
            tree = Tree()
152
 
 
153
 
        if type(entry) == InventoryFile:
154
 
            #FIXME: We can make potentially make this Lazy to avoid shaing lots of stuff
155
 
            # and having all these objects in memory at once
156
 
            blob = Blob()
157
 
            _, blob._text = repo.iter_files_bytes([(entry.file_id, entry.revision, path)]).next()
158
 
            sha = blob.sha().hexdigest()
159
 
            yield sha, blob, path
160
 
 
161
 
            name = urlutils.basename(path).encode("utf-8")
162
 
            mode = stat.S_IFREG | 0644
163
 
            if entry.executable:
164
 
                mode |= 0111
165
 
            tree.add(mode, name, sha)
166
 
 
167
 
    while len(stack) > 1:
168
 
        tree.serialize()
169
 
        sha = tree.sha().hexdigest()
170
 
        yield sha, tree, cur
171
 
        t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
172
 
        cur, tree = stack.pop()
173
 
        tree.add(*t)
174
 
 
175
 
    tree.serialize()
176
 
    yield tree.sha().hexdigest(), tree, cur
177
 
 
178
 
 
179
 
def revision_to_commit(rev, tree_sha, parent_lookup):
180
 
    """Turn a Bazaar revision in to a Git commit
181
 
 
182
 
    :param tree_sha: Tree sha for the commit
183
 
    :param parent_lookup: Function for looking up the GIT sha equiv of a bzr revision
184
 
    :return dulwich.objects.Commit represent the revision:
185
 
    """
186
 
    from dulwich.objects import Commit
187
 
    commit = Commit()
188
 
    commit._tree = tree_sha
189
 
    for p in rev.parent_ids:
190
 
        git_p = parent_lookup(p)
191
 
        if git_p is not None:
192
 
            commit._parents.append(git_p)
193
 
    commit._message = rev.message.encode("utf-8")
194
 
    commit._committer = rev.committer.encode("utf-8")
195
 
    commit._author = rev.get_apparent_authors()[0].encode("utf-8")
196
 
    commit._commit_time = long(rev.timestamp)
197
 
    commit.serialize()
198
 
    return commit
 
79
default_mapping = BzrGitMappingExperimental()