/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

Add progress bar when determining revisions to dpush

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
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
16
18
 
17
19
"""Converters, etc for going between Bazaar and Git ids."""
18
20
 
19
 
from bzrlib import errors, foreign
20
 
from bzrlib.inventory import ROOT_ID
 
21
import stat
 
22
 
 
23
from bzrlib import (
 
24
    errors,
 
25
    foreign,
 
26
    osutils,
 
27
    urlutils,
 
28
    )
 
29
from bzrlib.inventory import (
 
30
    ROOT_ID,
 
31
    )
21
32
from bzrlib.foreign import (
22
 
        ForeignRevision,
23
 
        )
 
33
    ForeignVcs, 
 
34
    VcsMappingRegistry, 
 
35
    ForeignRevision,
 
36
    )
 
37
from bzrlib.xml_serializer import (
 
38
    escape_invalid_chars,
 
39
    )
 
40
 
 
41
DEFAULT_FILE_MODE = stat.S_IFREG | 0644
24
42
 
25
43
 
26
44
def escape_file_id(file_id):
35
53
    """Class that maps between Git and Bazaar semantics."""
36
54
    experimental = False
37
55
 
38
 
    def revision_id_foreign_to_bzr(self, git_rev_id):
 
56
    def __init__(self):
 
57
        super(BzrGitMapping, self).__init__(foreign_git)
 
58
 
 
59
    def __eq__(self, other):
 
60
        return type(self) == type(other) and self.revid_prefix == other.revid_prefix
 
61
 
 
62
    @classmethod
 
63
    def revision_id_foreign_to_bzr(cls, git_rev_id):
39
64
        """Convert a git revision id handle to a Bazaar revision id."""
40
 
        return "%s:%s" % (self.revid_prefix, git_rev_id)
 
65
        return "%s:%s" % (cls.revid_prefix, git_rev_id)
41
66
 
42
 
    def revision_id_bzr_to_foreign(self, bzr_rev_id):
 
67
    @classmethod
 
68
    def revision_id_bzr_to_foreign(cls, bzr_rev_id):
43
69
        """Convert a Bazaar revision id to a git revision id handle."""
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 }
 
70
        if not bzr_rev_id.startswith("%s:" % cls.revid_prefix):
 
71
            raise errors.InvalidRevisionId(bzr_rev_id, cls)
 
72
        return bzr_rev_id[len(cls.revid_prefix)+1:], cls()
50
73
 
51
74
    def generate_file_id(self, path):
 
75
        # Git paths are just bytestrings
 
76
        # We must just hope they are valid UTF-8..
 
77
        assert isinstance(path, str)
52
78
        if path == "":
53
79
            return ROOT_ID
54
 
        return escape_file_id(path.encode('utf-8'))
 
80
        return escape_file_id(path)
 
81
 
 
82
    def parse_file_id(self, file_id):
 
83
        if file_id == ROOT_ID:
 
84
            return ""
 
85
        return unescape_file_id(file_id)
55
86
 
56
87
    def import_commit(self, commit):
57
88
        """Convert a git commit to a bzr revision.
62
93
            raise AssertionError("Commit object can't be None")
63
94
        rev = ForeignRevision(commit.id, self, self.revision_id_foreign_to_bzr(commit.id))
64
95
        rev.parent_ids = tuple([self.revision_id_foreign_to_bzr(p) for p in commit.parents])
65
 
        rev.message = commit.message.decode("utf-8", "replace")
66
 
        rev.committer = str(commit.committer).decode("utf-8", "replace")
 
96
        rev.message = escape_invalid_chars(commit.message.decode("utf-8", "replace"))[0]
 
97
        rev.committer = escape_invalid_chars(str(commit.committer).decode("utf-8", "replace"))[0]
67
98
        if commit.committer != commit.author:
68
 
            rev.properties['author'] = str(commit.author).decode("utf-8", "replace")
 
99
            rev.properties['author'] = escape_invalid_chars(str(commit.author).decode("utf-8", "replace"))[0]
 
100
 
 
101
        if commit.commit_time != commit.author_time:
 
102
            rev.properties['author-timestamp'] = str(commit.author_time)
 
103
        if commit.commit_timezone != commit.author_timezone:
 
104
            rev.properties['author-timezone'] = "%f" % (commit.author_timezone * .6)
69
105
        rev.timestamp = commit.commit_time
70
 
        rev.timezone = 0
 
106
        rev.timezone = int(commit.commit_timezone * .6)
 
107
        if rev.timezone / .6 != commit.commit_timezone:
 
108
            rev.properties['commit-timezone'] = "%f" % (commit.commit_timezone * .6)
71
109
        return rev
72
110
 
73
111
 
74
 
class BzrGitMappingExperimental(BzrGitMapping):
 
112
class BzrGitMappingv1(BzrGitMapping):
 
113
    revid_prefix = 'git-v1'
 
114
    experimental = False
 
115
 
 
116
 
 
117
class BzrGitMappingExperimental(BzrGitMappingv1):
75
118
    revid_prefix = 'git-experimental'
76
119
    experimental = True
77
120
 
78
121
 
79
 
default_mapping = BzrGitMappingExperimental()
 
122
class GitMappingRegistry(VcsMappingRegistry):
 
123
 
 
124
    def revision_id_bzr_to_foreign(self, bzr_revid):
 
125
        if not bzr_revid.startswith("git-"):
 
126
            raise errors.InvalidRevisionId(bzr_revid, None)
 
127
        (mapping_version, git_sha) = bzr_revid.split(":", 1)
 
128
        mapping = self.get(mapping_version)
 
129
        return mapping.revision_id_bzr_to_foreign(bzr_revid)
 
130
 
 
131
    parse_revision_id = revision_id_bzr_to_foreign
 
132
 
 
133
 
 
134
mapping_registry = GitMappingRegistry()
 
135
mapping_registry.register_lazy('git-v1', "bzrlib.plugins.git.mapping",
 
136
                                   "BzrGitMappingv1")
 
137
mapping_registry.register_lazy('git-experimental', "bzrlib.plugins.git.mapping",
 
138
                                   "BzrGitMappingExperimental")
 
139
 
 
140
 
 
141
class ForeignGit(ForeignVcs):
 
142
    """Foreign Git."""
 
143
 
 
144
    def __init__(self):
 
145
        super(ForeignGit, self).__init__(mapping_registry)
 
146
 
 
147
    @classmethod
 
148
    def show_foreign_revid(cls, foreign_revid):
 
149
        return { "git commit": foreign_revid }
 
150
 
 
151
 
 
152
foreign_git = ForeignGit()
 
153
default_mapping = BzrGitMappingv1()
 
154
 
 
155
 
 
156
def text_to_blob(texts, entry):
 
157
    from dulwich.objects import Blob
 
158
    text = texts.get_record_stream([(entry.file_id, entry.revision)], 'unordered', True).next().get_bytes_as('fulltext')
 
159
    blob = Blob()
 
160
    blob._text = text
 
161
    return blob
 
162
 
 
163
 
 
164
def symlink_to_blob(entry):
 
165
    from dulwich.objects import Blob
 
166
    blob = Blob()
 
167
    blob._text = entry.symlink_target
 
168
    return blob
 
169
 
 
170
 
 
171
def entry_mode(entry):
 
172
    if entry.kind == 'directory':
 
173
        return stat.S_IFDIR
 
174
    elif entry.kind == 'symlink':
 
175
        return stat.S_IFLNK
 
176
    elif entry.kind == 'file':
 
177
        mode = stat.S_IFREG | 0644
 
178
        if entry.executable:
 
179
            mode |= 0111
 
180
        return mode
 
181
    else:
 
182
        raise AssertionError
 
183
 
 
184
 
 
185
def directory_to_tree(entry, lookup_ie_sha1):
 
186
    from dulwich.objects import Tree
 
187
    tree = Tree()
 
188
    for name in sorted(entry.children.keys()):
 
189
        ie = entry.children[name]
 
190
        tree.add(entry_mode(ie), name.encode("utf-8"), lookup_ie_sha1(ie))
 
191
    tree.serialize()
 
192
    return tree
 
193
 
 
194
 
 
195
def inventory_to_tree_and_blobs(inventory, texts, mapping, cur=None):
 
196
    """Convert a Bazaar tree to a Git tree.
 
197
 
 
198
    :return: Yields tuples with object sha1, object and path
 
199
    """
 
200
    from dulwich.objects import Tree
 
201
    import stat
 
202
    stack = []
 
203
    if cur is None:
 
204
        cur = ""
 
205
    tree = Tree()
 
206
 
 
207
    # stack contains the set of trees that we haven't 
 
208
    # finished constructing
 
209
    for path, entry in inventory.iter_entries():
 
210
        while stack and not path.startswith(osutils.pathjoin(cur, "")):
 
211
            # We've hit a file that's not a child of the previous path
 
212
            tree.serialize()
 
213
            sha = tree.id
 
214
            yield sha, tree, cur.encode("utf-8")
 
215
            t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
 
216
            cur, tree = stack.pop()
 
217
            tree.add(*t)
 
218
 
 
219
        if entry.kind == "directory":
 
220
            stack.append((cur, tree))
 
221
            cur = path
 
222
            tree = Tree()
 
223
        else:
 
224
            if entry.kind == "file":
 
225
                blob = text_to_blob(texts, entry)
 
226
            elif entry.kind == "symlink":
 
227
                blob = symlink_to_blob(entry)
 
228
            else:
 
229
                raise AssertionError("Unknown kind %s" % entry.kind)
 
230
            sha = blob.id
 
231
            yield sha, blob, path.encode("utf-8")
 
232
            name = urlutils.basename(path).encode("utf-8")
 
233
            tree.add(entry_mode(entry), name, sha)
 
234
 
 
235
    while len(stack) > 1:
 
236
        tree.serialize()
 
237
        sha = tree.id
 
238
        yield sha, tree, cur.encode("utf-8")
 
239
        t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
 
240
        cur, tree = stack.pop()
 
241
        tree.add(*t)
 
242
 
 
243
    tree.serialize()
 
244
    yield tree.id, tree, cur.encode("utf-8")
 
245
 
 
246
 
 
247
def revision_to_commit(rev, tree_sha, parent_lookup):
 
248
    """Turn a Bazaar revision in to a Git commit
 
249
 
 
250
    :param tree_sha: Tree sha for the commit
 
251
    :param parent_lookup: Function for looking up the GIT sha equiv of a bzr revision
 
252
    :return dulwich.objects.Commit represent the revision:
 
253
    """
 
254
    from dulwich.objects import Commit
 
255
    commit = Commit()
 
256
    commit._tree = tree_sha
 
257
    for p in rev.parent_ids:
 
258
        git_p = parent_lookup(p)
 
259
        if git_p is not None:
 
260
            assert len(git_p) == 40, "unexpected length for %r" % git_p
 
261
            commit._parents.append(git_p)
 
262
    commit._message = rev.message.encode("utf-8")
 
263
    commit._committer = rev.committer.encode("utf-8")
 
264
    commit._author = rev.get_apparent_authors()[0].encode("utf-8")
 
265
    commit._commit_time = long(rev.timestamp)
 
266
    if 'author-timestamp' in rev.properties:
 
267
        commit._author_time = long(rev.properties['author-timestamp'])
 
268
    else:
 
269
        commit._author_time = commit._commit_time
 
270
    if 'committer-timezone' in rev.properties:
 
271
        commit._commit_timezone = int(float(rev.properties['commit-timezone']) / .6)
 
272
    else:
 
273
        commit._commit_timezone = int(rev.timezone / .6) 
 
274
    if 'author-timezone' in rev.properties:
 
275
        commit._author_timezone = int(float(rev.properties['author-timezone']) / .6)
 
276
    else:
 
277
        commit._author_timezone = commit._commit_timezone 
 
278
    commit.serialize()
 
279
    return commit