/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

Default to using global user id rather than making one up.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mapping.py
27
27
    trace,
28
28
    urlutils,
29
29
    )
30
 
try:
31
 
    from bzrlib import bencode
32
 
except ImportError:
33
 
    from bzrlib.util import bencode
34
30
from bzrlib.inventory import (
35
31
    ROOT_ID,
36
32
    )
39
35
    VcsMappingRegistry, 
40
36
    ForeignRevision,
41
37
    )
 
38
from bzrlib.xml_serializer import (
 
39
    escape_invalid_chars,
 
40
    )
42
41
 
43
42
DEFAULT_FILE_MODE = stat.S_IFREG | 0644
44
43
 
77
76
 
78
77
 
79
78
def warn_unusual_mode(commit, path, mode):
80
 
    trace.mutter("Unusual file mode %o for %s in %s. Storing as revision property. ",
81
 
                 mode, path, commit)
82
 
 
83
 
 
84
 
def squash_revision(target_repo, rev):
85
 
    """Remove characters that can't be stored from a revision, if necessary.
86
 
    
87
 
    :param target_repo: Repository in which the revision will be stored
88
 
    :param rev: Revision object, will be modified in-place
89
 
    """
90
 
    if not getattr(target_repo._serializer, "squashes_xml_invalid_characters", True):
91
 
        return
92
 
    from bzrlib.xml_serializer import escape_invalid_chars
93
 
    rev.message, num_escaped = escape_invalid_chars(rev.message)
94
 
    if num_escaped:
95
 
        warn_escaped(rev.foreign_revid, num_escaped)
96
 
    if 'author' in rev.properties:
97
 
        rev.properties['author'], num_escaped = escape_invalid_chars(
98
 
            rev.properties['author'])
99
 
        if num_escaped:
100
 
            warn_escaped(rev.foreign_revid, num_escaped)
101
 
    rev.committer, num_escaped = escape_invalid_chars(rev.committer)
102
 
    if num_escaped:
103
 
        warn_escaped(rev.foreign_revid, num_escaped)
 
79
    trace.warning("Unusual file mode %o for %s in %s. Will be unable to "
 
80
                  "regenerate the SHA map.", mode, path, commit)
104
81
 
105
82
 
106
83
class BzrGitMapping(foreign.VcsMapping):
137
114
            return ""
138
115
        return unescape_file_id(file_id)
139
116
 
140
 
    def import_unusual_file_modes(self, rev, unusual_file_modes):
141
 
        if unusual_file_modes:
142
 
            ret = [(name, unusual_file_modes[name]) for name in sorted(unusual_file_modes.keys())]
143
 
            rev.properties['file-modes'] = bencode.bencode(ret)
144
 
 
145
 
    def export_unusual_file_modes(self, rev):
146
 
        try:
147
 
            return dict([(self.generate_file_id(path), mode) for (path, mode) in bencode.bdecode(rev.properties['file-modes'])])
148
 
        except KeyError:
149
 
            return {}
150
 
 
151
117
    def import_commit(self, commit):
152
118
        """Convert a git commit to a bzr revision.
153
119
 
157
123
            raise AssertionError("Commit object can't be None")
158
124
        rev = ForeignRevision(commit.id, self, self.revision_id_foreign_to_bzr(commit.id))
159
125
        rev.parent_ids = tuple([self.revision_id_foreign_to_bzr(p) for p in commit.parents])
160
 
        rev.message = commit.message.decode("utf-8", "replace")
161
 
        rev.committer = str(commit.committer).decode("utf-8", "replace")
 
126
        rev.message, num_escaped = escape_invalid_chars(commit.message.decode("utf-8", "replace"))
 
127
        if num_escaped:
 
128
            warn_escaped(commit.id, num_escaped)
 
129
        rev.committer, num_escaped = escape_invalid_chars(str(commit.committer).decode("utf-8", "replace"))
 
130
        if num_escaped:
 
131
            warn_escaped(commit.id, num_escaped)
162
132
        if commit.committer != commit.author:
163
 
            rev.properties['author'] = str(commit.author).decode("utf-8", "replace")
 
133
            rev.properties['author'], num_escaped = escape_invalid_chars(str(commit.author).decode("utf-8", "replace"))
 
134
            if num_escaped:
 
135
                warn_escaped(commit.id, num_escaped)
164
136
 
165
137
        if commit.commit_time != commit.author_time:
166
138
            rev.properties['author-timestamp'] = str(commit.author_time)
185
157
 
186
158
 
187
159
class GitMappingRegistry(VcsMappingRegistry):
188
 
    """Registry with available git mappings."""
189
160
 
190
161
    def revision_id_bzr_to_foreign(self, bzr_revid):
191
162
        if not bzr_revid.startswith("git-"):
233
204
    blob._text = entry.symlink_target
234
205
    return blob
235
206
 
236
 
 
237
207
def mode_is_executable(mode):
238
 
    """Check if mode should be considered executable."""
239
208
    return bool(mode & 0111)
240
209
 
241
 
 
242
210
def mode_kind(mode):
243
 
    """Determine the Bazaar inventory kind based on Unix file mode."""
244
211
    entry_kind = (mode & 0700000) / 0100000
245
212
    if entry_kind == 0:
246
213
        return 'directory'
261
228
 
262
229
 
263
230
def entry_mode(entry):
264
 
    """Determine the git file mode for an inventory entry."""
265
231
    if entry.kind == 'directory':
266
232
        return stat.S_IFDIR
267
233
    elif entry.kind == 'symlink':
275
241
        raise AssertionError
276
242
 
277
243
 
278
 
def directory_to_tree(entry, lookup_ie_sha1, unusual_modes):
 
244
def directory_to_tree(entry, lookup_ie_sha1):
279
245
    from dulwich.objects import Tree
280
246
    tree = Tree()
281
247
    for name in sorted(entry.children.keys()):
282
248
        ie = entry.children[name]
283
 
        try:
284
 
            mode = unusual_modes[ie.file_id]
285
 
        except KeyError:
286
 
            mode = entry_mode(ie)
287
 
        tree.add(mode, name.encode("utf-8"), lookup_ie_sha1(ie))
 
249
        tree.add(entry_mode(ie), name.encode("utf-8"), lookup_ie_sha1(ie))
288
250
    tree.serialize()
289
251
    return tree
290
252
 
291
253
 
292
 
def extract_unusual_modes(rev):
293
 
    try:
294
 
        foreign_revid, mapping = mapping_registry.parse_revision_id(rev.revision_id)
295
 
    except errors.InvalidRevisionId:
296
 
        return {}
297
 
    else:
298
 
        return mapping.export_unusual_file_modes(rev)
299
 
 
300
 
 
301
 
def inventory_to_tree_and_blobs(inventory, texts, mapping, unusual_modes, cur=None):
 
254
def inventory_to_tree_and_blobs(inventory, texts, mapping, cur=None):
302
255
    """Convert a Bazaar tree to a Git tree.
303
256
 
304
257
    :return: Yields tuples with object sha1, object and path
318
271
            tree.serialize()
319
272
            sha = tree.id
320
273
            yield sha, tree, cur.encode("utf-8")
321
 
            mode = unusual_modes.get(cur.encode("utf-8"), stat.S_IFDIR)
322
 
            t = (mode, urlutils.basename(cur).encode('UTF-8'), sha)
 
274
            t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
323
275
            cur, tree = stack.pop()
324
276
            tree.add(*t)
325
277
 
337
289
            sha = blob.id
338
290
            yield sha, blob, path.encode("utf-8")
339
291
            name = urlutils.basename(path).encode("utf-8")
340
 
            mode = unusual_modes.get(path.encode("utf-8"), entry_mode(entry))
341
 
            tree.add(mode, name, sha)
 
292
            tree.add(entry_mode(entry), name, sha)
342
293
 
343
294
    while len(stack) > 1:
344
295
        tree.serialize()
345
296
        sha = tree.id
346
297
        yield sha, tree, cur.encode("utf-8")
347
 
        mode = unusual_modes.get(cur.encode('utf-8'), stat.S_IFDIR)
348
 
        t = (mode, urlutils.basename(cur).encode('UTF-8'), sha)
 
298
        t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
349
299
        cur, tree = stack.pop()
350
300
        tree.add(*t)
351
301