← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/annotate.py

  • Committer: Martin Pool
  • Date: 2010-07-16 15:20:17 UTC
  • mfrom: (5346.3.1 pathnotchild)
  • mto: This revision was merged to the branch mainline in revision 5351.
  • Revision ID: mbp@canonical.com-20100716152017-t4c73h9y1uoih7fb
PathNotChild should not give a traceback.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/annotate.py
1
 
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
28
28
import sys
29
29
import time
30
30
 
 
31
from bzrlib.lazy_import import lazy_import
 
32
lazy_import(globals(), """
 
33
from bzrlib import (
 
34
    patiencediff,
 
35
    tsort,
 
36
    )
 
37
""")
31
38
from bzrlib import (
32
39
    errors,
33
40
    osutils,
34
 
    patiencediff,
35
 
    tsort,
36
41
    )
37
42
from bzrlib.config import extract_email_address
38
43
from bzrlib.repository import _strip_NULL_ghosts
173
178
 
174
179
 
175
180
def _expand_annotations(annotations, branch, current_rev=None):
176
 
    """Expand a a files annotations into command line UI ready tuples.
 
181
    """Expand a file's annotations into command line UI ready tuples.
177
182
 
178
183
    Each tuple includes detailed information, such as the author name, and date
179
184
    string for the commit, rather than just the revision id.
188
193
        # or something.
189
194
        last_revision = current_rev.revision_id
190
195
        # XXX: Partially Cloned from branch, uses the old_get_graph, eep.
 
196
        # XXX: The main difficulty is that we need to inject a single new node
 
197
        #      (current_rev) into the graph before it gets numbered, etc.
 
198
        #      Once KnownGraph gets an 'add_node()' function, we can use
 
199
        #      VF.get_known_graph_ancestry().
191
200
        graph = repository.get_graph()
192
201
        revision_graph = dict(((key, value) for key, value in
193
202
            graph.iter_ancestry(current_rev.parent_ids) if value is not None))
252
261
        between the text and its left-hand-parent.  The format is
253
262
        the SequenceMatcher.get_matching_blocks format
254
263
        (start_left, start_right, length_of_match).
255
 
    :param heads_provider: An object which provids a .heads() call to resolve
 
264
    :param heads_provider: An object which provides a .heads() call to resolve
256
265
        if any revision ids are children of others.
257
266
        If None, then any ancestry disputes will be resolved with
258
267
        new_revision_id
308
317
 
309
318
 
310
319
def _get_matching_blocks(old, new):
311
 
    matcher = patiencediff.PatienceSequenceMatcher(None,
312
 
        old, new)
 
320
    matcher = patiencediff.PatienceSequenceMatcher(None, old, new)
313
321
    return matcher.get_matching_blocks()
314
322
 
315
323
 
 
324
_break_annotation_tie = None
 
325
 
 
326
def _old_break_annotation_tie(annotated_lines):
 
327
    """Chose an attribution between several possible ones.
 
328
 
 
329
    :param annotated_lines: A list of tuples ((file_id, rev_id), line) where
 
330
        the lines are identical but the revids different while no parent
 
331
        relation exist between them
 
332
 
 
333
     :return : The "winning" line. This must be one with a revid that
 
334
         guarantees that further criss-cross merges will converge. Failing to
 
335
         do so have performance implications.
 
336
    """
 
337
    # sort lexicographically so that we always get a stable result.
 
338
 
 
339
    # TODO: while 'sort' is the easiest (and nearly the only possible solution)
 
340
    # with the current implementation, chosing the oldest revision is known to
 
341
    # provide better results (as in matching user expectations). The most
 
342
    # common use case being manual cherry-pick from an already existing
 
343
    # revision.
 
344
    return sorted(annotated_lines)[0]
 
345
 
 
346
 
316
347
def _find_matching_unannotated_lines(output_lines, plain_child_lines,
317
348
                                     child_lines, start_child, end_child,
318
349
                                     right_lines, start_right, end_right,
323
354
    :param plain_child_lines: The unannotated new lines for the child text
324
355
    :param child_lines: Lines for the child text which have been annotated
325
356
        for the left parent
326
 
    :param start_child: Position in plain_child_lines and child_lines to start the
327
 
        match searching
328
 
    :param end_child: Last position in plain_child_lines and child_lines to search
329
 
        for a match
 
357
 
 
358
    :param start_child: Position in plain_child_lines and child_lines to start
 
359
        the match searching
 
360
    :param end_child: Last position in plain_child_lines and child_lines to
 
361
        search for a match
330
362
    :param right_lines: The annotated lines for the whole text for the right
331
363
        parent
332
364
    :param start_right: Position in right_lines to start the match
368
400
                    if len(heads) == 1:
369
401
                        output_append((iter(heads).next(), left[1]))
370
402
                    else:
371
 
                        # Both claim different origins, sort lexicographically
372
 
                        # so that we always get a stable result.
373
 
                        output_append(sorted([left, right])[0])
 
403
                        # Both claim different origins, get a stable result.
 
404
                        # If the result is not stable, there is a risk a
 
405
                        # performance degradation as criss-cross merges will
 
406
                        # flip-flop the attribution.
 
407
                        if _break_annotation_tie is None:
 
408
                            output_append(
 
409
                                _old_break_annotation_tie([left, right]))
 
410
                        else:
 
411
                            output_append(_break_annotation_tie([left, right]))
374
412
        last_child_idx = child_idx + match_len
375
413
 
376
414
 
400
438
    matching_left_and_right = _get_matching_blocks(right_parent_lines,
401
439
                                                   annotated_lines)
402
440
    for right_idx, left_idx, match_len in matching_left_and_right:
403
 
        # annotated lines from last_left_idx to left_idx did not match the lines from
404
 
        # last_right_idx
405
 
        # to right_idx, the raw lines should be compared to determine what annotations
406
 
        # need to be updated
 
441
        # annotated lines from last_left_idx to left_idx did not match the
 
442
        # lines from last_right_idx to right_idx, the raw lines should be
 
443
        # compared to determine what annotations need to be updated
407
444
        if last_right_idx == right_idx or last_left_idx == left_idx:
408
445
            # One of the sides is empty, so this is a pure insertion
409
446
            lines_extend(annotated_lines[last_left_idx:left_idx])
421
458
        # If left and right agree on a range, just push that into the output
422
459
        lines_extend(annotated_lines[left_idx:left_idx + match_len])
423
460
    return lines
 
461
 
 
462
 
 
463
try:
 
464
    from bzrlib._annotator_pyx import Annotator
 
465
except ImportError, e:
 
466
    osutils.failed_to_load_extension(e)
 
467
    from bzrlib._annotator_py import Annotator