/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 test for nick.

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