/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 basic infrastructure for dpush.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mapping.py
1
 
# Copyright (C) 2007 Canonical Ltd
2
 
# Copyright (C) 2008-2009 Jelmer Vernooij <jelmer@samba.org>
3
 
# Copyright (C) 2008 John Carr
 
1
# Copyright (C) 2007-2008 Canonical Ltd
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
 
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
 
    )
 
19
from bzrlib import errors, foreign
 
20
from bzrlib.inventory import ROOT_ID
32
21
from bzrlib.foreign import (
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
42
 
 
 
22
        ForeignVcs, 
 
23
        VcsMappingRegistry, 
 
24
        ForeignRevision,
 
25
        )
43
26
 
44
27
def escape_file_id(file_id):
45
28
    return file_id.replace('_', '__').replace(' ', '_s')
46
29
 
47
30
 
48
31
def unescape_file_id(file_id):
49
 
    ret = []
50
 
    i = 0
51
 
    while i < len(file_id):
52
 
        if file_id[i] != '_':
53
 
            ret.append(file_id[i])
54
 
        else:
55
 
            if file_id[i+1] == '_':
56
 
                ret.append("_")
57
 
            elif file_id[i+1] == 's':
58
 
                ret.append(" ")
59
 
            else:
60
 
                raise AssertionError("unknown escape character %s" % file_id[i+1])
61
 
            i += 1
62
 
        i += 1
63
 
    return "".join(ret)
64
 
 
65
 
 
66
 
def fix_person_identifier(text):
67
 
    if "<" in text and ">" in text:
68
 
        return text
69
 
    return "%s <%s>" % (text, text)
 
32
    return file_id.replace("_s", " ").replace("__", "_")
70
33
 
71
34
 
72
35
class BzrGitMapping(foreign.VcsMapping):
92
55
        return bzr_rev_id[len(cls.revid_prefix)+1:], cls()
93
56
 
94
57
    def generate_file_id(self, path):
95
 
        # Git paths are just bytestrings
96
 
        # We must just hope they are valid UTF-8..
97
58
        if path == "":
98
59
            return ROOT_ID
99
 
        return escape_file_id(path)
100
 
 
101
 
    def parse_file_id(self, file_id):
102
 
        if file_id == ROOT_ID:
103
 
            return ""
104
 
        return unescape_file_id(file_id)
 
60
        return escape_file_id(path.encode('utf-8'))
105
61
 
106
62
    def import_commit(self, commit):
107
63
        """Convert a git commit to a bzr revision.
112
68
            raise AssertionError("Commit object can't be None")
113
69
        rev = ForeignRevision(commit.id, self, self.revision_id_foreign_to_bzr(commit.id))
114
70
        rev.parent_ids = tuple([self.revision_id_foreign_to_bzr(p) for p in commit.parents])
115
 
        rev.message = escape_invalid_chars(commit.message.decode("utf-8", "replace"))[0]
116
 
        rev.committer = escape_invalid_chars(str(commit.committer).decode("utf-8", "replace"))[0]
 
71
        rev.message = commit.message.decode("utf-8", "replace")
 
72
        rev.committer = str(commit.committer).decode("utf-8", "replace")
117
73
        if commit.committer != commit.author:
118
 
            rev.properties['author'] = escape_invalid_chars(str(commit.author).decode("utf-8", "replace"))[0]
119
 
 
120
 
        if commit.commit_time != commit.author_time:
121
 
            rev.properties['author-timestamp'] = str(commit.author_time)
122
 
        if commit.commit_timezone != commit.author_timezone:
123
 
            rev.properties['author-timezone'] = "%f" % (commit.author_timezone * .6)
 
74
            rev.properties['author'] = str(commit.author).decode("utf-8", "replace")
124
75
        rev.timestamp = commit.commit_time
125
 
        rev.timezone = int(commit.commit_timezone * .6)
126
 
        if rev.timezone / .6 != commit.commit_timezone:
127
 
            rev.properties['commit-timezone'] = "%f" % (commit.commit_timezone * .6)
 
76
        rev.timezone = 0
128
77
        return rev
129
78
 
 
79
    def export_commit(self, rev, tree_sha):
 
80
        """Turn a Bazaar revision in to a Git commit
 
81
 
 
82
        :param tree_sha: HACK parameter (until we can retrieve this from the mapping)
 
83
        :return dulwich.objects.Commit represent the revision:
 
84
        """
 
85
        from dulwich.objects import Commit
 
86
        commit = Commit()
 
87
        commit._tree = tree_sha
 
88
        for p in rev.parent_ids:
 
89
            commit._parents.append(self.revision_id_bzr_to_foreign(p))
 
90
        commit._message = rev.message
 
91
        commit._committer = rev.committer
 
92
        if 'author' in rev.properties:
 
93
            commit._author = rev.properties['author']
 
94
        else:
 
95
            commit._author = rev.committer
 
96
        commit._commit_time = long(rev.timestamp)
 
97
        commit.serialize()
 
98
        return commit
 
99
 
130
100
 
131
101
class BzrGitMappingv1(BzrGitMapping):
132
102
    revid_prefix = 'git-v1'
133
103
    experimental = False
134
104
 
135
 
    def __str__(self):
136
 
        return self.revid_prefix
137
 
 
138
105
 
139
106
class BzrGitMappingExperimental(BzrGitMappingv1):
140
107
    revid_prefix = 'git-experimental'
161
128
 
162
129
 
163
130
class ForeignGit(ForeignVcs):
164
 
    """The Git Stupid Content Tracker"""
 
131
    """Foreign Git."""
165
132
 
166
133
    def __init__(self):
167
134
        super(ForeignGit, self).__init__(mapping_registry)
173
140
 
174
141
foreign_git = ForeignGit()
175
142
default_mapping = BzrGitMappingv1()
176
 
 
177
 
 
178
 
def text_to_blob(texts, entry):
179
 
    from dulwich.objects import Blob
180
 
    text = texts.get_record_stream([(entry.file_id, entry.revision)], 'unordered', True).next().get_bytes_as('fulltext')
181
 
    blob = Blob()
182
 
    blob._text = text
183
 
    return blob
184
 
 
185
 
 
186
 
def symlink_to_blob(entry):
187
 
    from dulwich.objects import Blob
188
 
    blob = Blob()
189
 
    blob._text = entry.symlink_target
190
 
    return blob
191
 
 
192
 
 
193
 
def entry_mode(entry):
194
 
    if entry.kind == 'directory':
195
 
        return stat.S_IFDIR
196
 
    elif entry.kind == 'symlink':
197
 
        return stat.S_IFLNK
198
 
    elif entry.kind == 'file':
199
 
        mode = stat.S_IFREG | 0644
200
 
        if entry.executable:
201
 
            mode |= 0111
202
 
        return mode
203
 
    else:
204
 
        raise AssertionError
205
 
 
206
 
 
207
 
def directory_to_tree(entry, lookup_ie_sha1):
208
 
    from dulwich.objects import Tree
209
 
    tree = Tree()
210
 
    for name in sorted(entry.children.keys()):
211
 
        ie = entry.children[name]
212
 
        tree.add(entry_mode(ie), name.encode("utf-8"), lookup_ie_sha1(ie))
213
 
    tree.serialize()
214
 
    return tree
215
 
 
216
 
 
217
 
def inventory_to_tree_and_blobs(inventory, texts, mapping, cur=None):
218
 
    """Convert a Bazaar tree to a Git tree.
219
 
 
220
 
    :return: Yields tuples with object sha1, object and path
221
 
    """
222
 
    from dulwich.objects import Tree
223
 
    import stat
224
 
    stack = []
225
 
    if cur is None:
226
 
        cur = ""
227
 
    tree = Tree()
228
 
 
229
 
    # stack contains the set of trees that we haven't 
230
 
    # finished constructing
231
 
    for path, entry in inventory.iter_entries():
232
 
        while stack and not path.startswith(osutils.pathjoin(cur, "")):
233
 
            # We've hit a file that's not a child of the previous path
234
 
            tree.serialize()
235
 
            sha = tree.id
236
 
            yield sha, tree, cur.encode("utf-8")
237
 
            t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
238
 
            cur, tree = stack.pop()
239
 
            tree.add(*t)
240
 
 
241
 
        if entry.kind == "directory":
242
 
            stack.append((cur, tree))
243
 
            cur = path
244
 
            tree = Tree()
245
 
        else:
246
 
            if entry.kind == "file":
247
 
                blob = text_to_blob(texts, entry)
248
 
            elif entry.kind == "symlink":
249
 
                blob = symlink_to_blob(entry)
250
 
            else:
251
 
                raise AssertionError("Unknown kind %s" % entry.kind)
252
 
            sha = blob.id
253
 
            yield sha, blob, path.encode("utf-8")
254
 
            name = urlutils.basename(path).encode("utf-8")
255
 
            tree.add(entry_mode(entry), name, sha)
256
 
 
257
 
    while len(stack) > 1:
258
 
        tree.serialize()
259
 
        sha = tree.id
260
 
        yield sha, tree, cur.encode("utf-8")
261
 
        t = (stat.S_IFDIR, urlutils.basename(cur).encode('UTF-8'), sha)
262
 
        cur, tree = stack.pop()
263
 
        tree.add(*t)
264
 
 
265
 
    tree.serialize()
266
 
    yield tree.id, tree, cur.encode("utf-8")
267
 
 
268
 
 
269
 
def revision_to_commit(rev, tree_sha, parent_lookup):
270
 
    """Turn a Bazaar revision in to a Git commit
271
 
 
272
 
    :param tree_sha: Tree sha for the commit
273
 
    :param parent_lookup: Function for looking up the GIT sha equiv of a bzr revision
274
 
    :return dulwich.objects.Commit represent the revision:
275
 
    """
276
 
    from dulwich.objects import Commit
277
 
    commit = Commit()
278
 
    commit._tree = tree_sha
279
 
    for p in rev.parent_ids:
280
 
        git_p = parent_lookup(p)
281
 
        if git_p is not None:
282
 
            assert len(git_p) == 40, "unexpected length for %r" % git_p
283
 
            commit._parents.append(git_p)
284
 
    commit._message = rev.message.encode("utf-8")
285
 
    commit._committer = fix_person_identifier(rev.committer.encode("utf-8"))
286
 
    commit._author = fix_person_identifier(rev.get_apparent_authors()[0].encode("utf-8"))
287
 
    commit._commit_time = long(rev.timestamp)
288
 
    if 'author-timestamp' in rev.properties:
289
 
        commit._author_time = long(rev.properties['author-timestamp'])
290
 
    else:
291
 
        commit._author_time = commit._commit_time
292
 
    if 'committer-timezone' in rev.properties:
293
 
        commit._commit_timezone = int(float(rev.properties['commit-timezone']) / .6)
294
 
    else:
295
 
        commit._commit_timezone = int(rev.timezone / .6) 
296
 
    if 'author-timezone' in rev.properties:
297
 
        commit._author_timezone = int(float(rev.properties['author-timezone']) / .6)
298
 
    else:
299
 
        commit._author_timezone = commit._commit_timezone 
300
 
    commit.serialize()
301
 
    return commit