← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revision.py

  • Committer: Martin Pool
  • Date: 2005-09-22 12:12:53 UTC
  • Revision ID: mbp@sourcefrog.net-20050922121253-eae2a3240ea5e493
- upgrade can no longer be done in current version branches
  so don't test it

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revision.py
16
16
 
17
17
 
18
18
import bzrlib.errors
19
 
from bzrlib.graph import node_distances, select_farthest, all_descendants
20
19
 
21
 
NULL_REVISION="null:"
22
20
 
23
21
class Revision(object):
24
22
    """Single revision on a branch.
137
135
    return matches
138
136
 
139
137
 
140
 
def old_common_ancestor(revision_a, revision_b, revision_source):
 
138
def common_ancestor(revision_a, revision_b, revision_source):
141
139
    """Find the ancestor common to both revisions that is closest to both.
142
140
    """
143
141
    from bzrlib.trace import mutter
168
166
        raise bzrlib.errors.AmbiguousBase((a_closest[0], b_closest[0]))
169
167
    return a_closest[0]
170
168
 
171
 
def revision_graph(revision, revision_source):
172
 
    """Produce a graph of the ancestry of the specified revision.
173
 
    Return root, ancestors map, descendants map
174
 
 
175
 
    TODO: Produce graphs with the NULL revision as root, so that we can find
176
 
    a common even when trees are not branches don't represent a single line
177
 
    of descent.
178
 
    """
179
 
    ancestors = {}
180
 
    descendants = {}
181
 
    lines = [revision]
182
 
    root = None
183
 
    descendants[revision] = {}
184
 
    while len(lines) > 0:
185
 
        new_lines = set()
186
 
        for line in lines:
187
 
            if line == NULL_REVISION:
188
 
                parents = []
189
 
                root = NULL_REVISION
190
 
            else:
191
 
                try:
192
 
                    rev = revision_source.get_revision(line)
193
 
                    parents = list(rev.parent_ids)
194
 
                    if len(parents) == 0:
195
 
                        parents = [NULL_REVISION]
196
 
                except bzrlib.errors.NoSuchRevision:
197
 
                    if line == revision:
198
 
                        raise
199
 
                    parents = None
200
 
            if parents is not None:
201
 
                for parent in parents:
202
 
                    if parent not in ancestors:
203
 
                        new_lines.add(parent)
204
 
                    if parent not in descendants:
205
 
                        descendants[parent] = {}
206
 
                    descendants[parent][line] = 1
207
 
            if parents is not None:
208
 
                ancestors[line] = set(parents)
209
 
        lines = new_lines
210
 
    assert root not in descendants[root]
211
 
    assert root not in ancestors[root]
212
 
    return root, ancestors, descendants
213
 
 
214
 
def combined_graph(revision_a, revision_b, revision_source):
215
 
    """Produce a combined ancestry graph.
216
 
    Return graph root, ancestors map, descendants map, set of common nodes"""
217
 
    root, ancestors, descendants = revision_graph(revision_a, revision_source)
218
 
    root_b, ancestors_b, descendants_b = revision_graph(revision_b, 
219
 
                                                        revision_source)
220
 
    if root != root_b:
221
 
        raise bzrlib.errors.NoCommonRoot(revision_a, revision_b)
222
 
    common = set()
223
 
    for node, node_anc in ancestors_b.iteritems():
224
 
        if node in ancestors:
225
 
            common.add(node)
226
 
        else:
227
 
            ancestors[node] = set()
228
 
        ancestors[node].update(node_anc)
229
 
    for node, node_dec in descendants_b.iteritems():
230
 
        if node not in descendants:
231
 
            descendants[node] = {}
232
 
        descendants[node].update(node_dec)
233
 
    return root, ancestors, descendants, common
234
 
 
235
 
def common_ancestor(revision_a, revision_b, revision_source):
236
 
    try:
237
 
        root, ancestors, descendants, common = \
238
 
            combined_graph(revision_a, revision_b, revision_source)
239
 
    except bzrlib.errors.NoCommonRoot:
240
 
        raise bzrlib.errors.NoCommonAncestor(revision_a, revision_b)
241
 
        
242
 
    distances = node_distances (descendants, ancestors, root)
243
 
    farthest = select_farthest(distances, common)
244
 
    if farthest is None or farthest == NULL_REVISION:
245
 
        raise bzrlib.errors.NoCommonAncestor(revision_a, revision_b)
246
 
    return farthest
247
 
 
248
169
class MultipleRevisionSources(object):
249
170
    """Proxy that looks in multiple branches for revisions."""
250
171
    def __init__(self, *args):
269
190
    Otherwise, rev_id will be the last entry.  ancestor_id will never appear.
270
191
    If ancestor_id is not an ancestor, NotAncestor will be thrown
271
192
    """
272
 
    root, ancestors, descendants = revision_graph(rev_id, rev_source)
273
 
    if len(descendants) == 0:
274
 
        raise NoSuchRevision(rev_source, rev_id)
275
 
    if ancestor_id not in descendants:
276
 
        rev_source.get_revision(ancestor_id)
277
 
        raise bzrlib.errors.NotAncestor(rev_id, ancestor_id)
278
 
    root_descendants = all_descendants(descendants, ancestor_id)
279
 
    root_descendants.add(ancestor_id)
280
 
    if rev_id not in root_descendants:
281
 
        raise bzrlib.errors.NotAncestor(rev_id, ancestor_id)
282
 
    distances = node_distances(descendants, ancestors, ancestor_id,
283
 
                               root_descendants=root_descendants)
284
 
 
285
 
    def best_ancestor(rev_id):
286
 
        best = None
287
 
        for anc_id in ancestors[rev_id]:
288
 
            try:
289
 
                distance = distances[anc_id]
290
 
            except KeyError:
291
 
                continue
292
 
            if revision_history is not None and anc_id in revision_history:
293
 
                return anc_id
294
 
            elif best is None or distance > best[1]:
295
 
                best = (anc_id, distance)
296
 
        return best[0]
297
 
 
298
 
    next = rev_id
299
 
    path = []
300
 
    while next != ancestor_id:
301
 
        path.append(next)
302
 
        next = best_ancestor(next)
303
 
    path.reverse()
304
 
    return path
 
193
    [rev_source.get_revision(r) for r in (ancestor_id, rev_id)]
 
194
    if ancestor_id == rev_id:
 
195
        return []
 
196
    def historical_lines(line):
 
197
        """Return a tuple of historical/non_historical lines, for sorting.
 
198
        The non_historical count is negative, since non_historical lines are
 
199
        a bad thing.
 
200
        """
 
201
        good_count = 0
 
202
        bad_count = 0
 
203
        for revision in line:
 
204
            if revision in revision_history:
 
205
                good_count += 1
 
206
            else:
 
207
                bad_count -= 1
 
208
        return good_count, bad_count
 
209
    active = [[rev_id]]
 
210
    successful_lines = []
 
211
    while len(active) > 0:
 
212
        new_active = []
 
213
        for line in active:
 
214
            for parent in rev_source.get_revision(line[-1]).parent_ids:
 
215
                line_copy = line[:]
 
216
                if parent == ancestor_id:
 
217
                    successful_lines.append(line_copy)
 
218
                else:
 
219
                    line_copy.append(parent)
 
220
                    new_active.append(line_copy)
 
221
        active = new_active
 
222
    if len(successful_lines) == 0:
 
223
        raise bzrlib.errors.NotAncestor(rev_id, ancestor_id)
 
224
    for line in successful_lines:
 
225
        line.reverse()
 
226
    if revision_history is not None:
 
227
        by_historical_lines = []
 
228
        for line in successful_lines:
 
229
            count = historical_lines(line)
 
230
            by_historical_lines.append((count, line))
 
231
        by_historical_lines.sort()
 
232
        if by_historical_lines[-1][0][0] > 0:
 
233
            return by_historical_lines[-1][1]
 
234
    assert len(successful_lines)
 
235
    successful_lines.sort(cmp, len)
 
236
    return successful_lines[-1]