/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 bzrlib/annotate.py

  • Committer: Frank Aspell
  • Date: 2009-02-22 16:54:02 UTC
  • mto: This revision was merged to the branch mainline in revision 4256.
  • Revision ID: frankaspell@googlemail.com-20090222165402-2myrucnu7er5w4ha
Fixing various typos

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/annotate.py
1
 
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2006, 2007 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""File annotate based on weave storage"""
18
18
 
19
19
# TODO: Choice of more or less verbose formats:
20
 
#
 
20
# 
21
21
# interposed: show more details between blocks of modified lines
22
22
 
23
23
# TODO: Show which revision caused a line to merge into the parent
24
24
 
25
25
# TODO: perhaps abbreviate timescales depending on how recent they are
26
 
# e.g. "3:12 Tue", "13 Oct", "Oct 2005", etc.
 
26
# e.g. "3:12 Tue", "13 Oct", "Oct 2005", etc.  
27
27
 
28
28
import sys
29
29
import time
168
168
def _annotations(repo, file_id, rev_id):
169
169
    """Return the list of (origin_revision_id, line_text) for a revision of a file in a repository."""
170
170
    annotations = repo.texts.annotate((file_id, rev_id))
171
 
    #
 
171
    # 
172
172
    return [(key[-1], line) for (key, line) in annotations]
173
173
 
174
174
 
188
188
        # or something.
189
189
        last_revision = current_rev.revision_id
190
190
        # XXX: Partially Cloned from branch, uses the old_get_graph, eep.
191
 
        # XXX: The main difficulty is that we need to inject a single new node
192
 
        #      (current_rev) into the graph before it gets numbered, etc.
193
 
        #      Once KnownGraph gets an 'add_node()' function, we can use
194
 
        #      VF.get_known_graph_ancestry().
195
191
        graph = repository.get_graph()
196
192
        revision_graph = dict(((key, value) for key, value in
197
193
            graph.iter_ancestry(current_rev.parent_ids) if value is not None))
214
210
        revision_id_to_revno[CURRENT_REVISION] = (
215
211
            "%d?" % (branch.revno() + 1),)
216
212
        revisions[CURRENT_REVISION] = current_rev
217
 
    revision_ids = [o for o in revision_ids if
 
213
    revision_ids = [o for o in revision_ids if 
218
214
                    repository.has_revision(o)]
219
 
    revisions.update((r.revision_id, r) for r in
 
215
    revisions.update((r.revision_id, r) for r in 
220
216
                     repository.get_revisions(revision_ids))
221
217
    for origin, text in annotations:
222
218
        text = text.rstrip('\r\n')
235
231
                                     time.gmtime(rev.timestamp + tz))
236
232
            # a lazy way to get something like the email address
237
233
            # TODO: Get real email address
238
 
            author = rev.get_apparent_authors()[0]
 
234
            author = rev.get_apparent_author()
239
235
            try:
240
236
                author = extract_email_address(author)
241
237
            except errors.NoEmailInUsername:
247
243
               _left_matching_blocks=None,
248
244
               heads_provider=None):
249
245
    """Create a new annotated version from new lines and parent annotations.
250
 
 
 
246
    
251
247
    :param parents_lines: List of annotated lines for all parents
252
248
    :param new_lines: The un-annotated new lines
253
249
    :param new_revision_id: The revision-id to associate with new lines
317
313
    return matcher.get_matching_blocks()
318
314
 
319
315
 
320
 
_break_annotation_tie = None
321
 
 
322
 
def _old_break_annotation_tie(annotated_lines):
323
 
    """Chose an attribution between several possible ones.
324
 
 
325
 
    :param annotated_lines: A list of tuples ((file_id, rev_id), line) where
326
 
        the lines are identical but the revids different while no parent
327
 
        relation exist between them
328
 
 
329
 
     :return : The "winning" line. This must be one with a revid that
330
 
         guarantees that further criss-cross merges will converge. Failing to
331
 
         do so have performance implications.
332
 
    """
333
 
    # sort lexicographically so that we always get a stable result.
334
 
 
335
 
    # TODO: while 'sort' is the easiest (and nearly the only possible solution)
336
 
    # with the current implementation, chosing the oldest revision is known to
337
 
    # provide better results (as in matching user expectations). The most
338
 
    # common use case being manual cherry-pick from an already existing
339
 
    # revision.
340
 
    return sorted(annotated_lines)[0]
341
 
 
342
 
 
343
316
def _find_matching_unannotated_lines(output_lines, plain_child_lines,
344
317
                                     child_lines, start_child, end_child,
345
318
                                     right_lines, start_right, end_right,
350
323
    :param plain_child_lines: The unannotated new lines for the child text
351
324
    :param child_lines: Lines for the child text which have been annotated
352
325
        for the left parent
353
 
 
354
 
    :param start_child: Position in plain_child_lines and child_lines to start
355
 
        the match searching
356
 
    :param end_child: Last position in plain_child_lines and child_lines to
357
 
        search for a match
 
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
358
330
    :param right_lines: The annotated lines for the whole text for the right
359
331
        parent
360
332
    :param start_right: Position in right_lines to start the match
396
368
                    if len(heads) == 1:
397
369
                        output_append((iter(heads).next(), left[1]))
398
370
                    else:
399
 
                        # Both claim different origins, get a stable result.
400
 
                        # If the result is not stable, there is a risk a
401
 
                        # performance degradation as criss-cross merges will
402
 
                        # flip-flop the attribution.
403
 
                        if _break_annotation_tie is None:
404
 
                            output_append(
405
 
                                _old_break_annotation_tie([left, right]))
406
 
                        else:
407
 
                            output_append(_break_annotation_tie([left, right]))
 
371
                        # Both claim different origins, sort lexicographically
 
372
                        # so that we always get a stable result.
 
373
                        output_append(sorted([left, right])[0])
408
374
        last_child_idx = child_idx + match_len
409
375
 
410
376
 
434
400
    matching_left_and_right = _get_matching_blocks(right_parent_lines,
435
401
                                                   annotated_lines)
436
402
    for right_idx, left_idx, match_len in matching_left_and_right:
437
 
        # annotated lines from last_left_idx to left_idx did not match the
438
 
        # lines from last_right_idx to right_idx, the raw lines should be
439
 
        # compared to determine what annotations need to be updated
 
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
440
407
        if last_right_idx == right_idx or last_left_idx == left_idx:
441
408
            # One of the sides is empty, so this is a pure insertion
442
409
            lines_extend(annotated_lines[last_left_idx:left_idx])
454
421
        # If left and right agree on a range, just push that into the output
455
422
        lines_extend(annotated_lines[left_idx:left_idx + match_len])
456
423
    return lines
457
 
 
458
 
 
459
 
try:
460
 
    from bzrlib._annotator_pyx import Annotator
461
 
except ImportError, e:
462
 
    osutils.failed_to_load_extension(e)
463
 
    from bzrlib._annotator_py import Annotator