/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 tree.py

More work on roundtrip push support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tree.py
28
28
    GitInventory,
29
29
    )
30
30
from bzrlib.plugins.git.mapping import (
 
31
    mode_is_executable,
31
32
    mode_kind,
32
33
    )
33
34
 
34
35
 
35
36
class GitRevisionTree(revisiontree.RevisionTree):
 
37
    """Revision tree implementation based on Git objects."""
36
38
 
37
39
    def __init__(self, repository, revision_id):
38
40
        self._revision_id = revision_id
39
41
        self._repository = repository
40
42
        store = repository._git.object_store
41
43
        assert isinstance(revision_id, str)
42
 
        git_id, self.mapping = repository.lookup_git_revid(revision_id)
 
44
        git_id, self.mapping = repository.lookup_bzr_revision_id(revision_id)
43
45
        try:
44
46
            commit = store[git_id]
45
47
        except KeyError, r:
46
48
            raise errors.NoSuchRevision(repository, revision_id)
47
49
        self.tree = commit.tree
48
 
        self._inventory = GitInventory(self.tree, self.mapping, store, 
49
 
                                       revision_id)
 
50
        fileid_map = self.mapping.get_fileid_map(store.__getitem__, self.tree)
 
51
        self._inventory = GitInventory(self.tree, self.mapping, fileid_map,
 
52
            store, revision_id)
50
53
 
51
54
    def get_revision_id(self):
 
55
        """See RevisionTree.get_revision_id."""
52
56
        return self._revision_id
53
57
 
54
58
    def get_file_text(self, file_id, path=None):
 
59
        """See RevisionTree.get_file_text."""
55
60
        if path is not None:
56
61
            entry = self._inventory._get_ie(path)
57
62
        else:
58
63
            entry = self._inventory[file_id]
59
 
        if entry.kind == 'directory': return ""
 
64
        if entry.kind in ('directory', 'tree-reference'):
 
65
            return ""
60
66
        return entry.object.data
61
67
 
62
68
 
63
 
def tree_delta_from_git_changes(changes, mapping, specific_file=None, 
64
 
                                require_versioned=False):
 
69
def tree_delta_from_git_changes(changes, mapping,
 
70
        (old_fileid_map, new_fileid_map), specific_file=None,
 
71
        require_versioned=False):
65
72
    """Create a TreeDelta from two git trees.
66
 
    
67
 
    source and target are iterators over tuples with: 
 
73
 
 
74
    source and target are iterators over tuples with:
68
75
        (filename, sha, mode)
69
76
    """
70
77
    ret = delta.TreeDelta()
71
78
    for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
 
79
        if mapping.is_control_file(oldpath):
 
80
            oldpath = None
 
81
        if mapping.is_control_file(newpath):
 
82
            newpath = None
 
83
        if oldpath is None and newpath is None:
 
84
            continue
72
85
        if oldpath is None:
73
 
            ret.added.append((newpath, mapping.generate_file_id(newpath), mode_kind(newmode)))
 
86
            ret.added.append((newpath, new_fileid_map.lookup_file_id(newpath.encode("utf-8")), mode_kind(newmode)))
74
87
        elif newpath is None:
75
 
            ret.removed.append((oldpath, mapping.generate_file_id(oldpath), mode_kind(oldmode)))
 
88
            ret.removed.append((oldpath, old_fileid_map.lookup_file_id(oldpath.encode("utf-8")), mode_kind(oldmode)))
76
89
        elif oldpath != newpath:
77
 
            ret.renamed.append((oldpath, newpath, mapping.generate_file_id(oldpath), mode_kind(newmode), (oldsha != newsha), (oldmode != newmode)))
 
90
            ret.renamed.append((oldpath, newpath, old_fileid_map.lookup_file_id(oldpath.encode("utf-8")), mode_kind(newmode), (oldsha != newsha), (oldmode != newmode)))
78
91
        elif mode_kind(oldmode) != mode_kind(newmode):
79
 
            ret.kind_changed.append((newpath, mapping.generate_file_id(newpath), mode_kind(oldmode), mode_kind(newmode)))
 
92
            ret.kind_changed.append((newpath, new_fileid_map.lookup_file_id(newpath.encode("utf-8")), mode_kind(oldmode), mode_kind(newmode)))
80
93
        elif oldsha != newsha or oldmode != newmode:
81
 
            ret.modified.append((newpath, mapping.generate_file_id(newpath), mode_kind(newmode), (oldsha != newsha), (oldmode != newmode)))
 
94
            ret.modified.append((newpath, new_fileid_map.lookup_file_id(newpath.encode("utf-8")), mode_kind(newmode), (oldsha != newsha), (oldmode != newmode)))
82
95
        else:
83
 
            ret.unchanged.append((newpath, mapping.generate_file_id(newpath), mode_kind(newmode)))
 
96
            ret.unchanged.append((newpath, new_fileid_map.lookup_file_id(newpath.encode("utf-8")), mode_kind(newmode)))
84
97
    return ret
85
98
 
86
99
 
 
100
def changes_from_git_changes(changes, mapping, specific_file=None,
 
101
                                require_versioned=False):
 
102
    """Create a iter_changes-like generator from a git stream.
 
103
 
 
104
    source and target are iterators over tuples with:
 
105
        (filename, sha, mode)
 
106
    """
 
107
    for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
 
108
        path = (oldpath, newpath)
 
109
        if oldpath is None:
 
110
            fileid = mapping.generate_file_id(newpath)
 
111
            oldexe = None
 
112
            oldkind = None
 
113
            oldname = None
 
114
            oldparent = None
 
115
        else:
 
116
            oldexe = mode_is_executable(oldmode)
 
117
            oldkind = mode_kind(oldmode)
 
118
            try:
 
119
                (oldparentpath, oldname) = oldpath.rsplit("/", 1)
 
120
            except ValueError:
 
121
                oldparent = None
 
122
                oldname = oldpath
 
123
            else:
 
124
                oldparent = mapping.generate_file_id(oldparentpath)
 
125
            fileid = mapping.generate_file_id(oldpath)
 
126
        if newpath is None:
 
127
            newexe = None
 
128
            newkind = None
 
129
            newname = None
 
130
            newparent = None
 
131
        else:
 
132
            newexe = mode_is_executable(newmode)
 
133
            newkind = mode_kind(newmode)
 
134
            try:
 
135
                newparentpath, newname = newpath.rsplit("/", 1)
 
136
            except ValueError:
 
137
                newparent = None
 
138
                newname = newpath
 
139
            else:
 
140
                newparent = mapping.generate_file_id(newparentpath)
 
141
        yield (fileid, (oldpath, newpath), (oldsha != newsha),
 
142
             (oldpath is not None, newpath is not None),
 
143
             (oldparent, newparent), (oldname, newname),
 
144
             (oldkind, newkind), (oldexe, newexe))
 
145
 
 
146
 
87
147
class InterGitRevisionTrees(tree.InterTree):
88
148
    """InterTree that works between two git revision trees."""
89
149
 
 
150
    _matching_from_tree_format = None
 
151
    _matching_to_tree_format = None
 
152
    _test_mutable_trees_to_test_trees = None
 
153
 
90
154
    @classmethod
91
155
    def is_compatible(cls, source, target):
92
 
        return (isinstance(source, GitRevisionTree) and 
 
156
        return (isinstance(source, GitRevisionTree) and
93
157
                isinstance(target, GitRevisionTree))
94
158
 
95
159
    def compare(self, want_unchanged=False, specific_files=None,
99
163
            raise AssertionError
100
164
        changes = self.source._repository._git.object_store.tree_changes(
101
165
            self.source.tree, self.target.tree, want_unchanged=want_unchanged)
102
 
        return tree_delta_from_git_changes(changes, self.target.mapping, 
 
166
        source_fileid_map = self.source.mapping.get_fileid_map(
 
167
            self.source._repository._git.object_store.__getitem__,
 
168
            self.source.tree)
 
169
        target_fileid_map = self.target.mapping.get_fileid_map(
 
170
            self.target._repository._git.object_store.__getitem__,
 
171
            self.target.tree)
 
172
        return tree_delta_from_git_changes(changes, self.target.mapping,
 
173
            (source_fileid_map, target_fileid_map),
 
174
            specific_file=specific_files)
 
175
 
 
176
    def iter_changes(self, include_unchanged=False, specific_files=None,
 
177
        pb=None, extra_trees=[], require_versioned=True,
 
178
        want_unversioned=False):
 
179
        if self.source._repository._git.object_store != self.target._repository._git.object_store:
 
180
            raise AssertionError
 
181
        changes = self.source._repository._git.object_store.tree_changes(
 
182
            self.source.tree, self.target.tree,
 
183
            want_unchanged=include_unchanged)
 
184
        return changes_from_git_changes(changes, self.target.mapping,
103
185
            specific_file=specific_files)
104
186
 
105
187