← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: John Arbash Meinel
  • Date: 2010-01-12 22:51:31 UTC
  • mto: This revision was merged to the branch mainline in revision 4955.
  • Revision ID: john@arbash-meinel.com-20100112225131-he8h411p6aeeb947
Delay grabbing an output stream until we actually go to show a diff.

This makes the test suite happy, but it also seems to be reasonable.
If we aren't going to write anything, we don't need to hold an
output stream open.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2009 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
88
88
    re_compile_checked,
89
89
    terminal_width,
90
90
    )
91
 
from bzrlib.symbol_versioning import (
92
 
    deprecated_function,
93
 
    deprecated_in,
94
 
    )
95
91
 
96
92
 
97
93
def find_touching_revisions(branch, file_id):
109
105
    last_path = None
110
106
    revno = 1
111
107
    for revision_id in branch.revision_history():
112
 
        this_inv = branch.repository.get_inventory(revision_id)
 
108
        this_inv = branch.repository.get_revision_inventory(revision_id)
113
109
        if file_id in this_inv:
114
110
            this_ie = this_inv[file_id]
115
111
            this_path = this_inv.id2path(file_id)
220
216
    'direction': 'reverse',
221
217
    'levels': 1,
222
218
    'generate_tags': True,
223
 
    'exclude_common_ancestry': False,
224
219
    '_match_using_deltas': True,
225
220
    }
226
221
 
227
222
 
228
223
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
 
                          start_revision=None, end_revision=None, limit=None,
230
 
                          message_search=None, levels=1, generate_tags=True,
231
 
                          delta_type=None,
232
 
                          diff_type=None, _match_using_deltas=True,
233
 
                          exclude_common_ancestry=False,
234
 
                          ):
 
224
    start_revision=None, end_revision=None, limit=None,
 
225
    message_search=None, levels=1, generate_tags=True, delta_type=None,
 
226
    diff_type=None, _match_using_deltas=True):
235
227
    """Convenience function for making a logging request dictionary.
236
228
 
237
229
    Using this function may make code slightly safer by ensuring
275
267
      algorithm used for matching specific_fileids. This parameter
276
268
      may be removed in the future so bzrlib client code should NOT
277
269
      use it.
278
 
 
279
 
    :param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
 
      range operator or as a graph difference.
281
270
    """
282
271
    return {
283
272
        'direction': direction,
290
279
        'generate_tags': generate_tags,
291
280
        'delta_type': delta_type,
292
281
        'diff_type': diff_type,
293
 
        'exclude_common_ancestry': exclude_common_ancestry,
294
282
        # Add 'private' attributes for features that may be deprecated
295
283
        '_match_using_deltas': _match_using_deltas,
296
284
    }
316
304
 
317
305
 
318
306
class Logger(object):
319
 
    """An object that generates, formats and displays a log."""
 
307
    """An object the generates, formats and displays a log."""
320
308
 
321
309
    def __init__(self, branch, rqst):
322
310
        """Create a Logger.
463
451
        generate_merge_revisions = rqst.get('levels') != 1
464
452
        delayed_graph_generation = not rqst.get('specific_fileids') and (
465
453
                rqst.get('limit') or self.start_rev_id or self.end_rev_id)
466
 
        view_revisions = _calc_view_revisions(
467
 
            self.branch, self.start_rev_id, self.end_rev_id,
468
 
            rqst.get('direction'),
469
 
            generate_merge_revisions=generate_merge_revisions,
470
 
            delayed_graph_generation=delayed_graph_generation,
471
 
            exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
 
454
        view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
 
455
            self.end_rev_id, rqst.get('direction'), generate_merge_revisions,
 
456
            delayed_graph_generation=delayed_graph_generation)
472
457
 
473
458
        # Apply the other filters
474
459
        return make_log_rev_iterator(self.branch, view_revisions,
481
466
        # Note that we always generate the merge revisions because
482
467
        # filter_revisions_touching_file_id() requires them ...
483
468
        rqst = self.rqst
484
 
        view_revisions = _calc_view_revisions(
485
 
            self.branch, self.start_rev_id, self.end_rev_id,
486
 
            rqst.get('direction'), generate_merge_revisions=True,
487
 
            exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
 
469
        view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
 
470
            self.end_rev_id, rqst.get('direction'), True)
488
471
        if not isinstance(view_revisions, list):
489
472
            view_revisions = list(view_revisions)
490
473
        view_revisions = _filter_revisions_touching_file_id(self.branch,
495
478
 
496
479
 
497
480
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
498
 
                         generate_merge_revisions,
499
 
                         delayed_graph_generation=False,
500
 
                         exclude_common_ancestry=False,
501
 
                         ):
 
481
    generate_merge_revisions, delayed_graph_generation=False):
502
482
    """Calculate the revisions to view.
503
483
 
504
484
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
505
485
             a list of the same tuples.
506
486
    """
507
 
    if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
 
        raise errors.BzrCommandError(
509
 
            '--exclude-common-ancestry requires two different revisions')
510
 
    if direction not in ('reverse', 'forward'):
511
 
        raise ValueError('invalid direction %r' % direction)
512
487
    br_revno, br_rev_id = branch.last_revision_info()
513
488
    if br_revno == 0:
514
489
        return []
515
490
 
516
 
    if (end_rev_id and start_rev_id == end_rev_id
517
 
        and (not generate_merge_revisions
518
 
             or not _has_merges(branch, end_rev_id))):
519
 
        # If a single revision is requested, check we can handle it
520
 
        iter_revs = _generate_one_revision(branch, end_rev_id, br_rev_id,
521
 
                                           br_revno)
522
 
    elif not generate_merge_revisions:
523
 
        # If we only want to see linear revisions, we can iterate ...
524
 
        iter_revs = _generate_flat_revisions(branch, start_rev_id, end_rev_id,
525
 
                                             direction)
526
 
        if direction == 'forward':
527
 
            iter_revs = reversed(iter_revs)
 
491
    # If a single revision is requested, check we can handle it
 
492
    generate_single_revision = (end_rev_id and start_rev_id == end_rev_id and
 
493
        (not generate_merge_revisions or not _has_merges(branch, end_rev_id)))
 
494
    if generate_single_revision:
 
495
        return _generate_one_revision(branch, end_rev_id, br_rev_id, br_revno)
 
496
 
 
497
    # If we only want to see linear revisions, we can iterate ...
 
498
    if not generate_merge_revisions:
 
499
        return _generate_flat_revisions(branch, start_rev_id, end_rev_id,
 
500
            direction)
528
501
    else:
529
 
        iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
530
 
                                            direction, delayed_graph_generation,
531
 
                                            exclude_common_ancestry)
532
 
        if direction == 'forward':
533
 
            iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
534
 
    return iter_revs
 
502
        return _generate_all_revisions(branch, start_rev_id, end_rev_id,
 
503
            direction, delayed_graph_generation)
535
504
 
536
505
 
537
506
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):
555
524
        except _StartNotLinearAncestor:
556
525
            raise errors.BzrCommandError('Start revision not found in'
557
526
                ' left-hand history of end revision.')
 
527
    if direction == 'forward':
 
528
        result = reversed(result)
558
529
    return result
559
530
 
560
531
 
561
532
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
 
                            delayed_graph_generation,
563
 
                            exclude_common_ancestry=False):
 
533
    delayed_graph_generation):
564
534
    # On large trees, generating the merge graph can take 30-60 seconds
565
535
    # so we delay doing it until a merge is detected, incrementally
566
536
    # returning initial (non-merge) revisions while we can.
567
 
 
568
 
    # The above is only true for old formats (<= 0.92), for newer formats, a
569
 
    # couple of seconds only should be needed to load the whole graph and the
570
 
    # other graph operations needed are even faster than that -- vila 100201
571
537
    initial_revisions = []
572
538
    if delayed_graph_generation:
573
539
        try:
574
 
            for rev_id, revno, depth in  _linear_view_revisions(
575
 
                branch, start_rev_id, end_rev_id):
 
540
            for rev_id, revno, depth in \
 
541
                _linear_view_revisions(branch, start_rev_id, end_rev_id):
576
542
                if _has_merges(branch, rev_id):
577
 
                    # The end_rev_id can be nested down somewhere. We need an
578
 
                    # explicit ancestry check. There is an ambiguity here as we
579
 
                    # may not raise _StartNotLinearAncestor for a revision that
580
 
                    # is an ancestor but not a *linear* one. But since we have
581
 
                    # loaded the graph to do the check (or calculate a dotted
582
 
                    # revno), we may as well accept to show the log...  We need
583
 
                    # the check only if start_rev_id is not None as all
584
 
                    # revisions have _mod_revision.NULL_REVISION as an ancestor
585
 
                    # -- vila 20100319
586
 
                    graph = branch.repository.get_graph()
587
 
                    if (start_rev_id is not None
588
 
                        and not graph.is_ancestor(start_rev_id, end_rev_id)):
589
 
                        raise _StartNotLinearAncestor()
590
 
                    # Since we collected the revisions so far, we need to
591
 
                    # adjust end_rev_id.
592
543
                    end_rev_id = rev_id
593
544
                    break
594
545
                else:
595
546
                    initial_revisions.append((rev_id, revno, depth))
596
547
            else:
597
548
                # No merged revisions found
598
 
                return initial_revisions
 
549
                if direction == 'reverse':
 
550
                    return initial_revisions
 
551
                elif direction == 'forward':
 
552
                    return reversed(initial_revisions)
 
553
                else:
 
554
                    raise ValueError('invalid direction %r' % direction)
599
555
        except _StartNotLinearAncestor:
600
556
            # A merge was never detected so the lower revision limit can't
601
557
            # be nested down somewhere
602
558
            raise errors.BzrCommandError('Start revision not found in'
603
559
                ' history of end revision.')
604
560
 
605
 
    # We exit the loop above because we encounter a revision with merges, from
606
 
    # this revision, we need to switch to _graph_view_revisions.
607
 
 
608
561
    # A log including nested merges is required. If the direction is reverse,
609
562
    # we rebase the initial merge depths so that the development line is
610
563
    # shown naturally, i.e. just like it is for linear logging. We can easily
612
565
    # indented at the end seems slightly nicer in that case.
613
566
    view_revisions = chain(iter(initial_revisions),
614
567
        _graph_view_revisions(branch, start_rev_id, end_rev_id,
615
 
                              rebase_initial_depths=(direction == 'reverse'),
616
 
                              exclude_common_ancestry=exclude_common_ancestry))
617
 
    return view_revisions
 
568
        rebase_initial_depths=direction == 'reverse'))
 
569
    if direction == 'reverse':
 
570
        return view_revisions
 
571
    elif direction == 'forward':
 
572
        # Forward means oldest first, adjusting for depth.
 
573
        view_revisions = reverse_by_depth(list(view_revisions))
 
574
        return _rebase_merge_depth(view_revisions)
 
575
    else:
 
576
        raise ValueError('invalid direction %r' % direction)
618
577
 
619
578
 
620
579
def _has_merges(branch, rev_id):
638
597
        else:
639
598
            # not obvious
640
599
            return False
641
 
    # if either start or end is not specified then we use either the first or
642
 
    # the last revision and *they* are obvious ancestors.
643
600
    return True
644
601
 
645
602
 
678
635
 
679
636
 
680
637
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
681
 
                          rebase_initial_depths=True,
682
 
                          exclude_common_ancestry=False):
 
638
    rebase_initial_depths=True):
683
639
    """Calculate revisions to view including merges, newest to oldest.
684
640
 
685
641
    :param branch: the branch
689
645
      revision is found?
690
646
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
691
647
    """
692
 
    if exclude_common_ancestry:
693
 
        stop_rule = 'with-merges-without-common-ancestry'
694
 
    else:
695
 
        stop_rule = 'with-merges'
696
648
    view_revisions = branch.iter_merge_sorted_revisions(
697
649
        start_revision_id=end_rev_id, stop_revision_id=start_rev_id,
698
 
        stop_rule=stop_rule)
 
650
        stop_rule="with-merges")
699
651
    if not rebase_initial_depths:
700
652
        for (rev_id, merge_depth, revno, end_of_merge
701
653
             ) in view_revisions:
712
664
                depth_adjustment = merge_depth
713
665
            if depth_adjustment:
714
666
                if merge_depth < depth_adjustment:
715
 
                    # From now on we reduce the depth adjustement, this can be
716
 
                    # surprising for users. The alternative requires two passes
717
 
                    # which breaks the fast display of the first revision
718
 
                    # though.
719
667
                    depth_adjustment = merge_depth
720
668
                merge_depth -= depth_adjustment
721
669
            yield rev_id, '.'.join(map(str, revno)), merge_depth
722
670
 
723
671
 
724
 
@deprecated_function(deprecated_in((2, 2, 0)))
725
672
def calculate_view_revisions(branch, start_revision, end_revision, direction,
726
673
        specific_fileid, generate_merge_revisions):
727
674
    """Calculate the revisions to view.
729
676
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
730
677
             a list of the same tuples.
731
678
    """
 
679
    # This method is no longer called by the main code path.
 
680
    # It is retained for API compatibility and may be deprecated
 
681
    # soon. IGC 20090116
732
682
    start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
733
683
        end_revision)
734
684
    view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
1084
1034
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
1085
1035
 
1086
1036
 
1087
 
@deprecated_function(deprecated_in((2, 2, 0)))
1088
1037
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1089
1038
    """Filter view_revisions based on revision ranges.
1090
1039
 
1099
1048
 
1100
1049
    :return: The filtered view_revisions.
1101
1050
    """
 
1051
    # This method is no longer called by the main code path.
 
1052
    # It may be removed soon. IGC 20090127
1102
1053
    if start_rev_id or end_rev_id:
1103
1054
        revision_ids = [r for r, n, d in view_revisions]
1104
1055
        if start_rev_id:
1210
1161
    return result
1211
1162
 
1212
1163
 
1213
 
@deprecated_function(deprecated_in((2, 2, 0)))
1214
1164
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1215
1165
                       include_merges=True):
1216
1166
    """Produce an iterator of revisions to show
1217
1167
    :return: an iterator of (revision_id, revno, merge_depth)
1218
1168
    (if there is no revno for a revision, None is supplied)
1219
1169
    """
 
1170
    # This method is no longer called by the main code path.
 
1171
    # It is retained for API compatibility and may be deprecated
 
1172
    # soon. IGC 20090127
1220
1173
    if not include_merges:
1221
1174
        revision_ids = mainline_revs[1:]
1222
1175
        if direction == 'reverse':
1340
1293
    preferred_levels = 0
1341
1294
 
1342
1295
    def __init__(self, to_file, show_ids=False, show_timezone='original',
1343
 
                 delta_format=None, levels=None, show_advice=False,
1344
 
                 to_exact_file=None):
 
1296
            delta_format=None, levels=None, show_advice=False,
 
1297
            to_exact_file=None):
1345
1298
        """Create a LogFormatter.
1346
1299
 
1347
1300
        :param to_file: the file to output to
1452
1405
        """
1453
1406
        # Revision comes directly from a foreign repository
1454
1407
        if isinstance(rev, foreign.ForeignRevision):
1455
 
            return self._format_properties(
1456
 
                rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
 
1408
            return rev.mapping.vcs.show_foreign_revid(rev.foreign_revid)
1457
1409
 
1458
1410
        # Imported foreign revision revision ids always contain :
1459
1411
        if not ":" in rev.revision_id:
1546
1498
        to_file = self.to_file
1547
1499
        to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1548
1500
        if revision.delta is not None:
1549
 
            # Use the standard status output to display changes
1550
 
            from bzrlib.delta import report_delta
1551
 
            report_delta(to_file, revision.delta, short_status=False, 
1552
 
                         show_ids=self.show_ids, indent=indent)
 
1501
            # We don't respect delta_format for compatibility
 
1502
            revision.delta.show(to_file, self.show_ids, indent=indent,
 
1503
                                short_status=False)
1553
1504
        if revision.diff is not None:
1554
1505
            to_file.write(indent + 'diff:\n')
1555
1506
            to_file.flush()
1618
1569
                to_file.write(indent + offset + '%s\n' % (l,))
1619
1570
 
1620
1571
        if revision.delta is not None:
1621
 
            # Use the standard status output to display changes
1622
 
            from bzrlib.delta import report_delta
1623
 
            report_delta(to_file, revision.delta, 
1624
 
                         short_status=self.delta_format==1, 
1625
 
                         show_ids=self.show_ids, indent=indent + offset)
 
1572
            revision.delta.show(to_file, self.show_ids, indent=indent + offset,
 
1573
                                short_status=self.delta_format==1)
1626
1574
        if revision.diff is not None:
1627
1575
            self.show_diff(self.to_exact_file, revision.diff, '      ')
1628
1576
        to_file.write('\n')
1703
1651
                               self.show_timezone,
1704
1652
                               date_fmt='%Y-%m-%d',
1705
1653
                               show_offset=False)
1706
 
        committer_str = revision.rev.get_apparent_authors()[0].replace (' <', '  <')
 
1654
        committer_str = revision.rev.committer.replace (' <', '  <')
1707
1655
        to_file.write('%s  %s\n\n' % (date_str,committer_str))
1708
1656
 
1709
1657
        if revision.delta is not None and revision.delta.has_changed():
2039
1987
        bug_rows = [line.split(' ', 1) for line in bug_lines]
2040
1988
        fixed_bug_urls = [row[0] for row in bug_rows if
2041
1989
                          len(row) > 1 and row[1] == 'fixed']
2042
 
 
 
1990
        
2043
1991
        if fixed_bug_urls:
2044
1992
            return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2045
1993
    return {}