/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

Revert locking fixes for now, as they break bzr 1.13 compatibility.

Show diffs side-by-side

added added

removed removed

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