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

Fix all tests but two, use rich roots by default.

Show diffs side-by-side

added added

removed removed

Lines of Context:
repository.py
69
69
        self.revisions = versionedfiles.VirtualRevisionTexts(self)
70
70
        self.tags = GitTags(self._git.get_tags())
71
71
 
72
 
    def _all_revision_ids(self):
73
 
        if self._git.heads == []:
74
 
            return set()
75
 
        ret = set()
76
 
        skip = 0
77
 
        max_count = 1000
78
 
        cms = None
79
 
        while cms != []:
80
 
            cms = self._git.commits("--all", max_count=max_count, skip=skip)
81
 
            skip += max_count
82
 
            ret.update([self.get_mapping().revision_id_foreign_to_bzr(cm.id) for cm in cms])
 
72
    def all_revision_ids(self):
 
73
        ret = set([revision.NULL_REVISION])
 
74
        if self._git.heads() == []:
 
75
            return ret
 
76
        bzr_heads = [self.get_mapping().revision_id_foreign_to_bzr(h) for h in self._git.heads()]
 
77
        ret = set(bzr_heads)
 
78
        graph = self.get_graph()
 
79
        for rev, parents in graph.iter_ancestry(bzr_heads):
 
80
            ret.add(rev)
83
81
        return ret
84
82
 
85
83
    def is_shared(self):
86
84
        return True
87
85
 
88
86
    def supports_rich_root(self):
89
 
        return False
 
87
        return True
90
88
 
91
89
    #def get_revision_delta(self, revision_id):
92
90
    #    parent_revid = self.get_revision(revision_id).parent_ids[0]
93
91
    #    diff = self._git.diff(ids.convert_revision_id_bzr_to_git(parent_revid),
94
92
    #                   ids.convert_revision_id_bzr_to_git(revision_id))
95
93
 
96
 
    def get_ancestry(self, revision_id):
97
 
        revision_id = revision.ensure_null(revision_id)
98
 
        ret = []
99
 
        if revision_id != revision.NULL_REVISION:
100
 
            skip = 0
101
 
            max_count = 1000
102
 
            cms = None
103
 
            while cms != []:
104
 
                cms = self._git.commits(self.lookup_git_revid(revision_id, self.get_mapping()), max_count=max_count, skip=skip)
105
 
                skip += max_count
106
 
                ret += [self.get_mapping().revision_id_foreign_to_bzr(cm.id) for cm in cms]
107
 
        return [None] + ret
 
94
    def get_parent_map(self, revids):
 
95
        parent_map = {}
 
96
        for revision_id in revids:
 
97
            assert isinstance(revision_id, str)
 
98
            if revision_id == revision.NULL_REVISION:
 
99
                parent_map[revision_id] = ()
 
100
                continue
 
101
            hexsha = self.lookup_git_revid(revision_id, self.get_mapping())
 
102
            commit  = self._git.commit(hexsha)
 
103
            if commit is None:
 
104
                continue
 
105
            else:
 
106
                parent_map[revision_id] = [self.get_mapping().revision_id_foreign_to_bzr(p) for p in commit.parents]
 
107
        return parent_map
 
108
 
 
109
    def get_ancestry(self, revision_id, topo_sorted=True):
 
110
        """See Repository.get_ancestry().
 
111
        """
 
112
        if revision_id is None:
 
113
            return self._all_revision_ids()
 
114
        assert isinstance(revision_id, str)
 
115
        ancestry = []
 
116
        graph = self.get_graph()
 
117
        for rev, parents in graph.iter_ancestry([revision_id]):
 
118
            if rev == revision.NULL_REVISION:
 
119
                rev = None
 
120
            ancestry.append(rev)
 
121
        ancestry.reverse()
 
122
        return ancestry
108
123
 
109
124
    def get_signature_text(self, revision_id):
110
125
        raise errors.NoSuchRevision(self, revision_id)
124
139
    def get_mapping(self):
125
140
        return default_mapping
126
141
 
127
 
    def get_parent_map(self, revision_ids):
128
 
        ret = {}
129
 
        for revid in revision_ids:
130
 
            if revid == revision.NULL_REVISION:
131
 
                ret[revid] = ()
132
 
            else:
133
 
                git_commit_id = self.lookup_git_revid(revid, self.get_mapping())
134
 
                commit = self._git.commit(git_commit_id)
135
 
                ret[revid] = tuple([self.get_mapping().revision_id_foreign_to_bzr(p.id) for p in commit.parents])
136
 
        return ret
137
 
 
138
142
    def lookup_git_revid(self, bzr_revid, mapping):
139
143
        try:
140
144
            return mapping.revision_id_bzr_to_foreign(bzr_revid)
141
145
        except errors.InvalidRevisionId:
142
 
            raise errors.NoSuchRevision(bzr_revid, self)
 
146
            raise errors.NoSuchRevision(self, bzr_revid)
143
147
 
144
148
    def get_revision(self, revision_id):
145
149
        git_commit_id = self.lookup_git_revid(revision_id, self.get_mapping())
146
150
        commit = self._git.commit(git_commit_id)
147
151
        # print "fetched revision:", git_commit_id
 
152
        if commit is None:
 
153
            raise errors.NoSuchRevision(self, revision_id)
148
154
        revision = self._parse_rev(commit, self.get_mapping())
 
155
        assert revision is not None
149
156
        return revision
150
157
 
151
158
    def has_revision(self, revision_id):
156
163
        else:
157
164
            return True
158
165
 
159
 
    def get_revisions(self, revisions):
160
 
        return [self.get_revision(r) for r in revisions]
 
166
    def get_revisions(self, revids):
 
167
        return (self.get_revision(r) for r in revids)
161
168
 
162
169
    @classmethod
163
170
    def _parse_rev(klass, commit, mapping):