← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009 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
69
69
    config,
70
70
    diff,
71
71
    errors,
 
72
    foreign,
 
73
    osutils,
72
74
    repository as _mod_repository,
73
75
    revision as _mod_revision,
74
76
    revisionspec,
82
84
    )
83
85
from bzrlib.osutils import (
84
86
    format_date,
 
87
    format_date_with_offset_in_original_timezone,
85
88
    get_terminal_encoding,
86
 
    re_compile_checked,
87
89
    terminal_width,
88
90
    )
 
91
from bzrlib.symbol_versioning import (
 
92
    deprecated_function,
 
93
    deprecated_in,
 
94
    )
89
95
 
90
96
 
91
97
def find_touching_revisions(branch, file_id):
103
109
    last_path = None
104
110
    revno = 1
105
111
    for revision_id in branch.revision_history():
106
 
        this_inv = branch.repository.get_revision_inventory(revision_id)
 
112
        this_inv = branch.repository.get_inventory(revision_id)
107
113
        if file_id in this_inv:
108
114
            this_ie = this_inv[file_id]
109
115
            this_path = this_inv.id2path(file_id)
214
220
    'direction': 'reverse',
215
221
    'levels': 1,
216
222
    'generate_tags': True,
 
223
    'exclude_common_ancestry': False,
217
224
    '_match_using_deltas': True,
218
225
    }
219
226
 
220
227
 
221
228
def make_log_request_dict(direction='reverse', specific_fileids=None,
222
 
    start_revision=None, end_revision=None, limit=None,
223
 
    message_search=None, levels=1, generate_tags=True, delta_type=None,
224
 
    diff_type=None, _match_using_deltas=True):
 
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
                          ):
225
235
    """Convenience function for making a logging request dictionary.
226
236
 
227
237
    Using this function may make code slightly safer by ensuring
265
275
      algorithm used for matching specific_fileids. This parameter
266
276
      may be removed in the future so bzrlib client code should NOT
267
277
      use it.
 
278
 
 
279
    :param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
 
280
      range operator or as a graph difference.
268
281
    """
269
282
    return {
270
283
        'direction': direction,
277
290
        'generate_tags': generate_tags,
278
291
        'delta_type': delta_type,
279
292
        'diff_type': diff_type,
 
293
        'exclude_common_ancestry': exclude_common_ancestry,
280
294
        # Add 'private' attributes for features that may be deprecated
281
295
        '_match_using_deltas': _match_using_deltas,
282
 
        '_allow_single_merge_revision': True,
283
296
    }
284
297
 
285
298
 
303
316
 
304
317
 
305
318
class Logger(object):
306
 
    """An object the generates, formats and displays a log."""
 
319
    """An object that generates, formats and displays a log."""
307
320
 
308
321
    def __init__(self, branch, rqst):
309
322
        """Create a Logger.
348
361
            rqst['delta_type'] = None
349
362
        if not getattr(lf, 'supports_diff', False):
350
363
            rqst['diff_type'] = None
351
 
        if not getattr(lf, 'supports_merge_revisions', False):
352
 
            rqst['_allow_single_merge_revision'] = getattr(lf,
353
 
                'supports_single_merge_revision', False)
354
364
 
355
365
        # Find and print the interesting revisions
356
366
        generator = self._generator_factory(self.branch, rqst)
357
367
        for lr in generator.iter_log_revisions():
358
368
            lf.log_revision(lr)
 
369
        lf.show_advice()
359
370
 
360
371
    def _generator_factory(self, branch, rqst):
361
372
        """Make the LogGenerator object to use.
386
397
        :return: An iterator yielding LogRevision objects.
387
398
        """
388
399
        rqst = self.rqst
 
400
        levels = rqst.get('levels')
 
401
        limit = rqst.get('limit')
 
402
        diff_type = rqst.get('diff_type')
389
403
        log_count = 0
390
404
        revision_iterator = self._create_log_revision_iterator()
391
405
        for revs in revision_iterator:
392
406
            for (rev_id, revno, merge_depth), rev, delta in revs:
393
407
                # 0 levels means show everything; merge_depth counts from 0
394
 
                levels = rqst.get('levels')
395
408
                if levels != 0 and merge_depth >= levels:
396
409
                    continue
397
 
                diff = self._format_diff(rev, rev_id)
 
410
                if diff_type is None:
 
411
                    diff = None
 
412
                else:
 
413
                    diff = self._format_diff(rev, rev_id, diff_type)
398
414
                yield LogRevision(rev, revno, merge_depth, delta,
399
415
                    self.rev_tag_dict.get(rev_id), diff)
400
 
                limit = rqst.get('limit')
401
416
                if limit:
402
417
                    log_count += 1
403
418
                    if log_count >= limit:
404
419
                        return
405
420
 
406
 
    def _format_diff(self, rev, rev_id):
407
 
        diff_type = self.rqst.get('diff_type')
408
 
        if diff_type is None:
409
 
            return None
 
421
    def _format_diff(self, rev, rev_id, diff_type):
410
422
        repo = self.branch.repository
411
423
        if len(rev.parent_ids) == 0:
412
424
            ancestor_id = _mod_revision.NULL_REVISION
420
432
        else:
421
433
            specific_files = None
422
434
        s = StringIO()
 
435
        path_encoding = osutils.get_diff_header_encoding()
423
436
        diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
424
 
            new_label='')
 
437
            new_label='', path_encoding=path_encoding)
425
438
        return s.getvalue()
426
439
 
427
440
    def _create_log_revision_iterator(self):
451
464
        generate_merge_revisions = rqst.get('levels') != 1
452
465
        delayed_graph_generation = not rqst.get('specific_fileids') and (
453
466
                rqst.get('limit') or self.start_rev_id or self.end_rev_id)
454
 
        view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
455
 
            self.end_rev_id, rqst.get('direction'), generate_merge_revisions,
456
 
            rqst.get('_allow_single_merge_revision'),
457
 
            delayed_graph_generation=delayed_graph_generation)
 
467
        view_revisions = _calc_view_revisions(
 
468
            self.branch, self.start_rev_id, self.end_rev_id,
 
469
            rqst.get('direction'),
 
470
            generate_merge_revisions=generate_merge_revisions,
 
471
            delayed_graph_generation=delayed_graph_generation,
 
472
            exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
458
473
 
459
474
        # Apply the other filters
460
475
        return make_log_rev_iterator(self.branch, view_revisions,
467
482
        # Note that we always generate the merge revisions because
468
483
        # filter_revisions_touching_file_id() requires them ...
469
484
        rqst = self.rqst
470
 
        view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
471
 
            self.end_rev_id, rqst.get('direction'), True,
472
 
            rqst.get('_allow_single_merge_revision'))
 
485
        view_revisions = _calc_view_revisions(
 
486
            self.branch, self.start_rev_id, self.end_rev_id,
 
487
            rqst.get('direction'), generate_merge_revisions=True,
 
488
            exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
473
489
        if not isinstance(view_revisions, list):
474
490
            view_revisions = list(view_revisions)
475
491
        view_revisions = _filter_revisions_touching_file_id(self.branch,
480
496
 
481
497
 
482
498
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
483
 
    generate_merge_revisions, allow_single_merge_revision,
484
 
    delayed_graph_generation=False):
 
499
                         generate_merge_revisions,
 
500
                         delayed_graph_generation=False,
 
501
                         exclude_common_ancestry=False,
 
502
                         ):
485
503
    """Calculate the revisions to view.
486
504
 
487
505
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
488
506
             a list of the same tuples.
489
507
    """
 
508
    if (exclude_common_ancestry and start_rev_id == end_rev_id):
 
509
        raise errors.BzrCommandError(
 
510
            '--exclude-common-ancestry requires two different revisions')
 
511
    if direction not in ('reverse', 'forward'):
 
512
        raise ValueError('invalid direction %r' % direction)
490
513
    br_revno, br_rev_id = branch.last_revision_info()
491
514
    if br_revno == 0:
492
515
        return []
493
516
 
494
 
    # If a single revision is requested, check we can handle it
495
 
    generate_single_revision = (end_rev_id and start_rev_id == end_rev_id and
496
 
        (not generate_merge_revisions or not _has_merges(branch, end_rev_id)))
497
 
    if generate_single_revision:
498
 
        return _generate_one_revision(branch, end_rev_id, br_rev_id, br_revno,
499
 
            allow_single_merge_revision)
500
 
 
501
 
    # If we only want to see linear revisions, we can iterate ...
502
 
    if not generate_merge_revisions:
503
 
        return _generate_flat_revisions(branch, start_rev_id, end_rev_id,
504
 
            direction)
 
517
    if (end_rev_id and start_rev_id == end_rev_id
 
518
        and (not generate_merge_revisions
 
519
             or not _has_merges(branch, end_rev_id))):
 
520
        # If a single revision is requested, check we can handle it
 
521
        iter_revs = _generate_one_revision(branch, end_rev_id, br_rev_id,
 
522
                                           br_revno)
 
523
    elif not generate_merge_revisions:
 
524
        # If we only want to see linear revisions, we can iterate ...
 
525
        iter_revs = _generate_flat_revisions(branch, start_rev_id, end_rev_id,
 
526
                                             direction, exclude_common_ancestry)
 
527
        if direction == 'forward':
 
528
            iter_revs = reversed(iter_revs)
505
529
    else:
506
 
        return _generate_all_revisions(branch, start_rev_id, end_rev_id,
507
 
            direction, delayed_graph_generation)
508
 
 
509
 
 
510
 
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno,
511
 
    allow_single_merge_revision):
 
530
        iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
 
531
                                            direction, delayed_graph_generation,
 
532
                                            exclude_common_ancestry)
 
533
        if direction == 'forward':
 
534
            iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
 
535
    return iter_revs
 
536
 
 
537
 
 
538
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):
512
539
    if rev_id == br_rev_id:
513
540
        # It's the tip
514
541
        return [(br_rev_id, br_revno, 0)]
515
542
    else:
516
543
        revno = branch.revision_id_to_dotted_revno(rev_id)
517
 
        if len(revno) > 1 and not allow_single_merge_revision:
518
 
            # It's a merge revision and the log formatter is
519
 
            # completely brain dead. This "feature" of allowing
520
 
            # log formatters incapable of displaying dotted revnos
521
 
            # ought to be deprecated IMNSHO. IGC 20091022
522
 
            raise errors.BzrCommandError('Selected log formatter only'
523
 
                ' supports mainline revisions.')
524
544
        revno_str = '.'.join(str(n) for n in revno)
525
545
        return [(rev_id, revno_str, 0)]
526
546
 
527
547
 
528
 
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction):
529
 
    result = _linear_view_revisions(branch, start_rev_id, end_rev_id)
 
548
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction,
 
549
                             exclude_common_ancestry=False):
 
550
    result = _linear_view_revisions(
 
551
        branch, start_rev_id, end_rev_id,
 
552
        exclude_common_ancestry=exclude_common_ancestry)
530
553
    # If a start limit was given and it's not obviously an
531
554
    # ancestor of the end limit, check it before outputting anything
532
555
    if direction == 'forward' or (start_rev_id
536
559
        except _StartNotLinearAncestor:
537
560
            raise errors.BzrCommandError('Start revision not found in'
538
561
                ' left-hand history of end revision.')
539
 
    if direction == 'forward':
540
 
        result = reversed(result)
541
562
    return result
542
563
 
543
564
 
544
565
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
545
 
    delayed_graph_generation):
 
566
                            delayed_graph_generation,
 
567
                            exclude_common_ancestry=False):
546
568
    # On large trees, generating the merge graph can take 30-60 seconds
547
569
    # so we delay doing it until a merge is detected, incrementally
548
570
    # returning initial (non-merge) revisions while we can.
 
571
 
 
572
    # The above is only true for old formats (<= 0.92), for newer formats, a
 
573
    # couple of seconds only should be needed to load the whole graph and the
 
574
    # other graph operations needed are even faster than that -- vila 100201
549
575
    initial_revisions = []
550
576
    if delayed_graph_generation:
551
577
        try:
552
 
            for rev_id, revno, depth in \
553
 
                _linear_view_revisions(branch, start_rev_id, end_rev_id):
 
578
            for rev_id, revno, depth in  _linear_view_revisions(
 
579
                branch, start_rev_id, end_rev_id, exclude_common_ancestry):
554
580
                if _has_merges(branch, rev_id):
 
581
                    # The end_rev_id can be nested down somewhere. We need an
 
582
                    # explicit ancestry check. There is an ambiguity here as we
 
583
                    # may not raise _StartNotLinearAncestor for a revision that
 
584
                    # is an ancestor but not a *linear* one. But since we have
 
585
                    # loaded the graph to do the check (or calculate a dotted
 
586
                    # revno), we may as well accept to show the log...  We need
 
587
                    # the check only if start_rev_id is not None as all
 
588
                    # revisions have _mod_revision.NULL_REVISION as an ancestor
 
589
                    # -- vila 20100319
 
590
                    graph = branch.repository.get_graph()
 
591
                    if (start_rev_id is not None
 
592
                        and not graph.is_ancestor(start_rev_id, end_rev_id)):
 
593
                        raise _StartNotLinearAncestor()
 
594
                    # Since we collected the revisions so far, we need to
 
595
                    # adjust end_rev_id.
555
596
                    end_rev_id = rev_id
556
597
                    break
557
598
                else:
558
599
                    initial_revisions.append((rev_id, revno, depth))
559
600
            else:
560
601
                # No merged revisions found
561
 
                if direction == 'reverse':
562
 
                    return initial_revisions
563
 
                elif direction == 'forward':
564
 
                    return reversed(initial_revisions)
565
 
                else:
566
 
                    raise ValueError('invalid direction %r' % direction)
 
602
                return initial_revisions
567
603
        except _StartNotLinearAncestor:
568
604
            # A merge was never detected so the lower revision limit can't
569
605
            # be nested down somewhere
570
606
            raise errors.BzrCommandError('Start revision not found in'
571
607
                ' history of end revision.')
572
608
 
 
609
    # We exit the loop above because we encounter a revision with merges, from
 
610
    # this revision, we need to switch to _graph_view_revisions.
 
611
 
573
612
    # A log including nested merges is required. If the direction is reverse,
574
613
    # we rebase the initial merge depths so that the development line is
575
614
    # shown naturally, i.e. just like it is for linear logging. We can easily
577
616
    # indented at the end seems slightly nicer in that case.
578
617
    view_revisions = chain(iter(initial_revisions),
579
618
        _graph_view_revisions(branch, start_rev_id, end_rev_id,
580
 
        rebase_initial_depths=direction == 'reverse'))
581
 
    if direction == 'reverse':
582
 
        return view_revisions
583
 
    elif direction == 'forward':
584
 
        # Forward means oldest first, adjusting for depth.
585
 
        view_revisions = reverse_by_depth(list(view_revisions))
586
 
        return _rebase_merge_depth(view_revisions)
587
 
    else:
588
 
        raise ValueError('invalid direction %r' % direction)
 
619
                              rebase_initial_depths=(direction == 'reverse'),
 
620
                              exclude_common_ancestry=exclude_common_ancestry))
 
621
    return view_revisions
589
622
 
590
623
 
591
624
def _has_merges(branch, rev_id):
609
642
        else:
610
643
            # not obvious
611
644
            return False
 
645
    # if either start or end is not specified then we use either the first or
 
646
    # the last revision and *they* are obvious ancestors.
612
647
    return True
613
648
 
614
649
 
615
 
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
 
650
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
 
651
                           exclude_common_ancestry=False):
616
652
    """Calculate a sequence of revisions to view, newest to oldest.
617
653
 
618
654
    :param start_rev_id: the lower revision-id
619
655
    :param end_rev_id: the upper revision-id
 
656
    :param exclude_common_ancestry: Whether the start_rev_id should be part of
 
657
        the iterated revisions.
620
658
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
621
659
    :raises _StartNotLinearAncestor: if a start_rev_id is specified but
622
 
      is not found walking the left-hand history
 
660
        is not found walking the left-hand history
623
661
    """
624
662
    br_revno, br_rev_id = branch.last_revision_info()
625
663
    repo = branch.repository
636
674
            revno = branch.revision_id_to_dotted_revno(revision_id)
637
675
            revno_str = '.'.join(str(n) for n in revno)
638
676
            if not found_start and revision_id == start_rev_id:
639
 
                yield revision_id, revno_str, 0
 
677
                if not exclude_common_ancestry:
 
678
                    yield revision_id, revno_str, 0
640
679
                found_start = True
641
680
                break
642
681
            else:
647
686
 
648
687
 
649
688
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
650
 
    rebase_initial_depths=True):
 
689
                          rebase_initial_depths=True,
 
690
                          exclude_common_ancestry=False):
651
691
    """Calculate revisions to view including merges, newest to oldest.
652
692
 
653
693
    :param branch: the branch
657
697
      revision is found?
658
698
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
659
699
    """
 
700
    if exclude_common_ancestry:
 
701
        stop_rule = 'with-merges-without-common-ancestry'
 
702
    else:
 
703
        stop_rule = 'with-merges'
660
704
    view_revisions = branch.iter_merge_sorted_revisions(
661
705
        start_revision_id=end_rev_id, stop_revision_id=start_rev_id,
662
 
        stop_rule="with-merges")
 
706
        stop_rule=stop_rule)
663
707
    if not rebase_initial_depths:
664
708
        for (rev_id, merge_depth, revno, end_of_merge
665
709
             ) in view_revisions:
676
720
                depth_adjustment = merge_depth
677
721
            if depth_adjustment:
678
722
                if merge_depth < depth_adjustment:
 
723
                    # From now on we reduce the depth adjustement, this can be
 
724
                    # surprising for users. The alternative requires two passes
 
725
                    # which breaks the fast display of the first revision
 
726
                    # though.
679
727
                    depth_adjustment = merge_depth
680
728
                merge_depth -= depth_adjustment
681
729
            yield rev_id, '.'.join(map(str, revno)), merge_depth
682
730
 
683
731
 
 
732
@deprecated_function(deprecated_in((2, 2, 0)))
684
733
def calculate_view_revisions(branch, start_revision, end_revision, direction,
685
 
        specific_fileid, generate_merge_revisions, allow_single_merge_revision):
 
734
        specific_fileid, generate_merge_revisions):
686
735
    """Calculate the revisions to view.
687
736
 
688
737
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
689
738
             a list of the same tuples.
690
739
    """
691
 
    # This method is no longer called by the main code path.
692
 
    # It is retained for API compatibility and may be deprecated
693
 
    # soon. IGC 20090116
694
740
    start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
695
741
        end_revision)
696
742
    view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
697
 
        direction, generate_merge_revisions or specific_fileid,
698
 
        allow_single_merge_revision))
 
743
        direction, generate_merge_revisions or specific_fileid))
699
744
    if specific_fileid:
700
745
        view_revisions = _filter_revisions_touching_file_id(branch,
701
746
            specific_fileid, view_revisions,
765
810
    """
766
811
    if search is None:
767
812
        return log_rev_iterator
768
 
    searchRE = re_compile_checked(search, re.IGNORECASE,
769
 
            'log message filter')
 
813
    searchRE = re.compile(search, re.IGNORECASE)
770
814
    return _filter_message_re(searchRE, log_rev_iterator)
771
815
 
772
816
 
1047
1091
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
1048
1092
 
1049
1093
 
 
1094
@deprecated_function(deprecated_in((2, 2, 0)))
1050
1095
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1051
1096
    """Filter view_revisions based on revision ranges.
1052
1097
 
1061
1106
 
1062
1107
    :return: The filtered view_revisions.
1063
1108
    """
1064
 
    # This method is no longer called by the main code path.
1065
 
    # It may be removed soon. IGC 20090127
1066
1109
    if start_rev_id or end_rev_id:
1067
1110
        revision_ids = [r for r, n, d in view_revisions]
1068
1111
        if start_rev_id:
1174
1217
    return result
1175
1218
 
1176
1219
 
 
1220
@deprecated_function(deprecated_in((2, 2, 0)))
1177
1221
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1178
1222
                       include_merges=True):
1179
1223
    """Produce an iterator of revisions to show
1180
1224
    :return: an iterator of (revision_id, revno, merge_depth)
1181
1225
    (if there is no revno for a revision, None is supplied)
1182
1226
    """
1183
 
    # This method is no longer called by the main code path.
1184
 
    # It is retained for API compatibility and may be deprecated
1185
 
    # soon. IGC 20090127
1186
1227
    if not include_merges:
1187
1228
        revision_ids = mainline_revs[1:]
1188
1229
        if direction == 'reverse':
1283
1324
        one (2) should be used.
1284
1325
 
1285
1326
    - supports_merge_revisions must be True if this log formatter supports
1286
 
        merge revisions.  If not, and if supports_single_merge_revision is
1287
 
        also not True, then only mainline revisions will be passed to the
1288
 
        formatter.
 
1327
        merge revisions.  If not, then only mainline revisions will be passed
 
1328
        to the formatter.
1289
1329
 
1290
1330
    - preferred_levels is the number of levels this formatter defaults to.
1291
1331
        The default value is zero meaning display all levels.
1292
1332
        This value is only relevant if supports_merge_revisions is True.
1293
1333
 
1294
 
    - supports_single_merge_revision must be True if this log formatter
1295
 
        supports logging only a single merge revision.  This flag is
1296
 
        only relevant if supports_merge_revisions is not True.
1297
 
 
1298
1334
    - supports_tags must be True if this log formatter supports tags.
1299
1335
        Otherwise the tags attribute may not be populated.
1300
1336
 
1311
1347
    preferred_levels = 0
1312
1348
 
1313
1349
    def __init__(self, to_file, show_ids=False, show_timezone='original',
1314
 
                 delta_format=None, levels=None):
 
1350
                 delta_format=None, levels=None, show_advice=False,
 
1351
                 to_exact_file=None, author_list_handler=None):
1315
1352
        """Create a LogFormatter.
1316
1353
 
1317
1354
        :param to_file: the file to output to
 
1355
        :param to_exact_file: if set, gives an output stream to which 
 
1356
             non-Unicode diffs are written.
1318
1357
        :param show_ids: if True, revision-ids are to be displayed
1319
1358
        :param show_timezone: the timezone to use
1320
1359
        :param delta_format: the level of delta information to display
1321
 
          or None to leave it u to the formatter to decide
 
1360
          or None to leave it to the formatter to decide
1322
1361
        :param levels: the number of levels to display; None or -1 to
1323
1362
          let the log formatter decide.
 
1363
        :param show_advice: whether to show advice at the end of the
 
1364
          log or not
 
1365
        :param author_list_handler: callable generating a list of
 
1366
          authors to display for a given revision
1324
1367
        """
1325
1368
        self.to_file = to_file
1326
1369
        # 'exact' stream used to show diff, it should print content 'as is'
1327
1370
        # and should not try to decode/encode it to unicode to avoid bug #328007
1328
 
        self.to_exact_file = getattr(to_file, 'stream', to_file)
 
1371
        if to_exact_file is not None:
 
1372
            self.to_exact_file = to_exact_file
 
1373
        else:
 
1374
            # XXX: somewhat hacky; this assumes it's a codec writer; it's better
 
1375
            # for code that expects to get diffs to pass in the exact file
 
1376
            # stream
 
1377
            self.to_exact_file = getattr(to_file, 'stream', to_file)
1329
1378
        self.show_ids = show_ids
1330
1379
        self.show_timezone = show_timezone
1331
1380
        if delta_format is None:
1333
1382
            delta_format = 2 # long format
1334
1383
        self.delta_format = delta_format
1335
1384
        self.levels = levels
 
1385
        self._show_advice = show_advice
 
1386
        self._merge_count = 0
 
1387
        self._author_list_handler = author_list_handler
1336
1388
 
1337
1389
    def get_levels(self):
1338
1390
        """Get the number of levels to display or 0 for all."""
1339
1391
        if getattr(self, 'supports_merge_revisions', False):
1340
1392
            if self.levels is None or self.levels == -1:
1341
 
                return self.preferred_levels
1342
 
            else:
1343
 
                return self.levels
1344
 
        return 1
 
1393
                self.levels = self.preferred_levels
 
1394
        else:
 
1395
            self.levels = 1
 
1396
        return self.levels
1345
1397
 
1346
1398
    def log_revision(self, revision):
1347
1399
        """Log a revision.
1350
1402
        """
1351
1403
        raise NotImplementedError('not implemented in abstract base')
1352
1404
 
 
1405
    def show_advice(self):
 
1406
        """Output user advice, if any, when the log is completed."""
 
1407
        if self._show_advice and self.levels == 1 and self._merge_count > 0:
 
1408
            advice_sep = self.get_advice_separator()
 
1409
            if advice_sep:
 
1410
                self.to_file.write(advice_sep)
 
1411
            self.to_file.write(
 
1412
                "Use --include-merges or -n0 to see merged revisions.\n")
 
1413
 
 
1414
    def get_advice_separator(self):
 
1415
        """Get the text separating the log from the closing advice."""
 
1416
        return ''
 
1417
 
1353
1418
    def short_committer(self, rev):
1354
1419
        name, address = config.parse_username(rev.committer)
1355
1420
        if name:
1357
1422
        return address
1358
1423
 
1359
1424
    def short_author(self, rev):
1360
 
        name, address = config.parse_username(rev.get_apparent_authors()[0])
1361
 
        if name:
1362
 
            return name
1363
 
        return address
 
1425
        return self.authors(rev, 'first', short=True, sep=', ')
 
1426
 
 
1427
    def authors(self, rev, who, short=False, sep=None):
 
1428
        """Generate list of authors, taking --authors option into account.
 
1429
 
 
1430
        The caller has to specify the name of a author list handler,
 
1431
        as provided by the author list registry, using the ``who``
 
1432
        argument.  That name only sets a default, though: when the
 
1433
        user selected a different author list generation using the
 
1434
        ``--authors`` command line switch, as represented by the
 
1435
        ``author_list_handler`` constructor argument, that value takes
 
1436
        precedence.
 
1437
 
 
1438
        :param rev: The revision for which to generate the list of authors.
 
1439
        :param who: Name of the default handler.
 
1440
        :param short: Whether to shorten names to either name or address.
 
1441
        :param sep: What separator to use for automatic concatenation.
 
1442
        """
 
1443
        if self._author_list_handler is not None:
 
1444
            # The user did specify --authors, which overrides the default
 
1445
            author_list_handler = self._author_list_handler
 
1446
        else:
 
1447
            # The user didn't specify --authors, so we use the caller's default
 
1448
            author_list_handler = author_list_registry.get(who)
 
1449
        names = author_list_handler(rev)
 
1450
        if short:
 
1451
            for i in range(len(names)):
 
1452
                name, address = config.parse_username(names[i])
 
1453
                if name:
 
1454
                    names[i] = name
 
1455
                else:
 
1456
                    names[i] = address
 
1457
        if sep is not None:
 
1458
            names = sep.join(names)
 
1459
        return names
 
1460
 
 
1461
    def merge_marker(self, revision):
 
1462
        """Get the merge marker to include in the output or '' if none."""
 
1463
        if len(revision.rev.parent_ids) > 1:
 
1464
            self._merge_count += 1
 
1465
            return ' [merge]'
 
1466
        else:
 
1467
            return ''
1364
1468
 
1365
1469
    def show_properties(self, revision, indent):
1366
1470
        """Displays the custom properties returned by each registered handler.
1367
1471
 
1368
1472
        If a registered handler raises an error it is propagated.
1369
1473
        """
 
1474
        for line in self.custom_properties(revision):
 
1475
            self.to_file.write("%s%s\n" % (indent, line))
 
1476
 
 
1477
    def custom_properties(self, revision):
 
1478
        """Format the custom properties returned by each registered handler.
 
1479
 
 
1480
        If a registered handler raises an error it is propagated.
 
1481
 
 
1482
        :return: a list of formatted lines (excluding trailing newlines)
 
1483
        """
 
1484
        lines = self._foreign_info_properties(revision)
1370
1485
        for key, handler in properties_handler_registry.iteritems():
1371
 
            for key, value in handler(revision).items():
1372
 
                self.to_file.write(indent + key + ': ' + value + '\n')
 
1486
            lines.extend(self._format_properties(handler(revision)))
 
1487
        return lines
 
1488
 
 
1489
    def _foreign_info_properties(self, rev):
 
1490
        """Custom log displayer for foreign revision identifiers.
 
1491
 
 
1492
        :param rev: Revision object.
 
1493
        """
 
1494
        # Revision comes directly from a foreign repository
 
1495
        if isinstance(rev, foreign.ForeignRevision):
 
1496
            return self._format_properties(
 
1497
                rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
 
1498
 
 
1499
        # Imported foreign revision revision ids always contain :
 
1500
        if not ":" in rev.revision_id:
 
1501
            return []
 
1502
 
 
1503
        # Revision was once imported from a foreign repository
 
1504
        try:
 
1505
            foreign_revid, mapping = \
 
1506
                foreign.foreign_vcs_registry.parse_revision_id(rev.revision_id)
 
1507
        except errors.InvalidRevisionId:
 
1508
            return []
 
1509
 
 
1510
        return self._format_properties(
 
1511
            mapping.vcs.show_foreign_revid(foreign_revid))
 
1512
 
 
1513
    def _format_properties(self, properties):
 
1514
        lines = []
 
1515
        for key, value in properties.items():
 
1516
            lines.append(key + ': ' + value)
 
1517
        return lines
1373
1518
 
1374
1519
    def show_diff(self, to_file, diff, indent):
1375
1520
        for l in diff.rstrip().split('\n'):
1376
1521
            to_file.write(indent + '%s\n' % (l,))
1377
1522
 
1378
1523
 
 
1524
# Separator between revisions in long format
 
1525
_LONG_SEP = '-' * 60
 
1526
 
 
1527
 
1379
1528
class LongLogFormatter(LogFormatter):
1380
1529
 
1381
1530
    supports_merge_revisions = True
 
1531
    preferred_levels = 1
1382
1532
    supports_delta = True
1383
1533
    supports_tags = True
1384
1534
    supports_diff = True
1385
1535
 
 
1536
    def __init__(self, *args, **kwargs):
 
1537
        super(LongLogFormatter, self).__init__(*args, **kwargs)
 
1538
        if self.show_timezone == 'original':
 
1539
            self.date_string = self._date_string_original_timezone
 
1540
        else:
 
1541
            self.date_string = self._date_string_with_timezone
 
1542
 
 
1543
    def _date_string_with_timezone(self, rev):
 
1544
        return format_date(rev.timestamp, rev.timezone or 0,
 
1545
                           self.show_timezone)
 
1546
 
 
1547
    def _date_string_original_timezone(self, rev):
 
1548
        return format_date_with_offset_in_original_timezone(rev.timestamp,
 
1549
            rev.timezone or 0)
 
1550
 
1386
1551
    def log_revision(self, revision):
1387
1552
        """Log a revision, either merged or not."""
1388
1553
        indent = '    ' * revision.merge_depth
1389
 
        to_file = self.to_file
1390
 
        to_file.write(indent + '-' * 60 + '\n')
 
1554
        lines = [_LONG_SEP]
1391
1555
        if revision.revno is not None:
1392
 
            to_file.write(indent + 'revno: %s\n' % (revision.revno,))
 
1556
            lines.append('revno: %s%s' % (revision.revno,
 
1557
                self.merge_marker(revision)))
1393
1558
        if revision.tags:
1394
 
            to_file.write(indent + 'tags: %s\n' % (', '.join(revision.tags)))
 
1559
            lines.append('tags: %s' % (', '.join(revision.tags)))
1395
1560
        if self.show_ids:
1396
 
            to_file.write(indent + 'revision-id: ' + revision.rev.revision_id)
1397
 
            to_file.write('\n')
 
1561
            lines.append('revision-id: %s' % (revision.rev.revision_id,))
1398
1562
            for parent_id in revision.rev.parent_ids:
1399
 
                to_file.write(indent + 'parent: %s\n' % (parent_id,))
1400
 
        self.show_properties(revision.rev, indent)
 
1563
                lines.append('parent: %s' % (parent_id,))
 
1564
        lines.extend(self.custom_properties(revision.rev))
1401
1565
 
1402
1566
        committer = revision.rev.committer
1403
 
        authors = revision.rev.get_apparent_authors()
 
1567
        authors = self.authors(revision.rev, 'all')
1404
1568
        if authors != [committer]:
1405
 
            to_file.write(indent + 'author: %s\n' % (", ".join(authors),))
1406
 
        to_file.write(indent + 'committer: %s\n' % (committer,))
 
1569
            lines.append('author: %s' % (", ".join(authors),))
 
1570
        lines.append('committer: %s' % (committer,))
1407
1571
 
1408
1572
        branch_nick = revision.rev.properties.get('branch-nick', None)
1409
1573
        if branch_nick is not None:
1410
 
            to_file.write(indent + 'branch nick: %s\n' % (branch_nick,))
1411
 
 
1412
 
        date_str = format_date(revision.rev.timestamp,
1413
 
                               revision.rev.timezone or 0,
1414
 
                               self.show_timezone)
1415
 
        to_file.write(indent + 'timestamp: %s\n' % (date_str,))
1416
 
 
1417
 
        to_file.write(indent + 'message:\n')
 
1574
            lines.append('branch nick: %s' % (branch_nick,))
 
1575
 
 
1576
        lines.append('timestamp: %s' % (self.date_string(revision.rev),))
 
1577
 
 
1578
        lines.append('message:')
1418
1579
        if not revision.rev.message:
1419
 
            to_file.write(indent + '  (no message)\n')
 
1580
            lines.append('  (no message)')
1420
1581
        else:
1421
1582
            message = revision.rev.message.rstrip('\r\n')
1422
1583
            for l in message.split('\n'):
1423
 
                to_file.write(indent + '  %s\n' % (l,))
 
1584
                lines.append('  %s' % (l,))
 
1585
 
 
1586
        # Dump the output, appending the delta and diff if requested
 
1587
        to_file = self.to_file
 
1588
        to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1424
1589
        if revision.delta is not None:
1425
 
            # We don't respect delta_format for compatibility
1426
 
            revision.delta.show(to_file, self.show_ids, indent=indent,
1427
 
                                short_status=False)
 
1590
            # Use the standard status output to display changes
 
1591
            from bzrlib.delta import report_delta
 
1592
            report_delta(to_file, revision.delta, short_status=False, 
 
1593
                         show_ids=self.show_ids, indent=indent)
1428
1594
        if revision.diff is not None:
1429
1595
            to_file.write(indent + 'diff:\n')
 
1596
            to_file.flush()
1430
1597
            # Note: we explicitly don't indent the diff (relative to the
1431
1598
            # revision information) so that the output can be fed to patch -p0
1432
1599
            self.show_diff(self.to_exact_file, revision.diff, indent)
 
1600
            self.to_exact_file.flush()
 
1601
 
 
1602
    def get_advice_separator(self):
 
1603
        """Get the text separating the log from the closing advice."""
 
1604
        return '-' * 60 + '\n'
1433
1605
 
1434
1606
 
1435
1607
class ShortLogFormatter(LogFormatter):
1465
1637
        offset = ' ' * (revno_width + 1)
1466
1638
 
1467
1639
        to_file = self.to_file
1468
 
        is_merge = ''
1469
 
        if len(revision.rev.parent_ids) > 1:
1470
 
            is_merge = ' [merge]'
1471
1640
        tags = ''
1472
1641
        if revision.tags:
1473
1642
            tags = ' {%s}' % (', '.join(revision.tags))
1477
1646
                            revision.rev.timezone or 0,
1478
1647
                            self.show_timezone, date_fmt="%Y-%m-%d",
1479
1648
                            show_offset=False),
1480
 
                tags, is_merge))
 
1649
                tags, self.merge_marker(revision)))
1481
1650
        self.show_properties(revision.rev, indent+offset)
1482
1651
        if self.show_ids:
1483
1652
            to_file.write(indent + offset + 'revision-id:%s\n'
1490
1659
                to_file.write(indent + offset + '%s\n' % (l,))
1491
1660
 
1492
1661
        if revision.delta is not None:
1493
 
            revision.delta.show(to_file, self.show_ids, indent=indent + offset,
1494
 
                                short_status=self.delta_format==1)
 
1662
            # Use the standard status output to display changes
 
1663
            from bzrlib.delta import report_delta
 
1664
            report_delta(to_file, revision.delta, 
 
1665
                         short_status=self.delta_format==1, 
 
1666
                         show_ids=self.show_ids, indent=indent + offset)
1495
1667
        if revision.diff is not None:
1496
1668
            self.show_diff(self.to_exact_file, revision.diff, '      ')
1497
1669
        to_file.write('\n')
1505
1677
 
1506
1678
    def __init__(self, *args, **kwargs):
1507
1679
        super(LineLogFormatter, self).__init__(*args, **kwargs)
1508
 
        self._max_chars = terminal_width() - 1
 
1680
        width = terminal_width()
 
1681
        if width is not None:
 
1682
            # we need one extra space for terminals that wrap on last char
 
1683
            width = width - 1
 
1684
        self._max_chars = width
1509
1685
 
1510
1686
    def truncate(self, str, max_len):
1511
 
        if len(str) <= max_len:
 
1687
        if max_len is None or len(str) <= max_len:
1512
1688
            return str
1513
 
        return str[:max_len-3]+'...'
 
1689
        return str[:max_len-3] + '...'
1514
1690
 
1515
1691
    def date_string(self, rev):
1516
1692
        return format_date(rev.timestamp, rev.timezone or 0,
1568
1744
                               self.show_timezone,
1569
1745
                               date_fmt='%Y-%m-%d',
1570
1746
                               show_offset=False)
1571
 
        committer_str = revision.rev.committer.replace (' <', '  <')
 
1747
        committer_str = self.authors(revision.rev, 'first', sep=', ')
 
1748
        committer_str = committer_str.replace(' <', '  <')
1572
1749
        to_file.write('%s  %s\n\n' % (date_str,committer_str))
1573
1750
 
1574
1751
        if revision.delta is not None and revision.delta.has_changed():
1639
1816
        raise errors.BzrCommandError("unknown log formatter: %r" % name)
1640
1817
 
1641
1818
 
 
1819
def author_list_all(rev):
 
1820
    return rev.get_apparent_authors()[:]
 
1821
 
 
1822
 
 
1823
def author_list_first(rev):
 
1824
    lst = rev.get_apparent_authors()
 
1825
    try:
 
1826
        return [lst[0]]
 
1827
    except IndexError:
 
1828
        return []
 
1829
 
 
1830
 
 
1831
def author_list_committer(rev):
 
1832
    return [rev.committer]
 
1833
 
 
1834
 
 
1835
author_list_registry = registry.Registry()
 
1836
 
 
1837
author_list_registry.register('all', author_list_all,
 
1838
                              'All authors')
 
1839
 
 
1840
author_list_registry.register('first', author_list_first,
 
1841
                              'The first author')
 
1842
 
 
1843
author_list_registry.register('committer', author_list_committer,
 
1844
                              'The committer')
 
1845
 
 
1846
 
1642
1847
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1643
1848
    # deprecated; for compatibility
1644
1849
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
1795
2000
        lf.log_revision(lr)
1796
2001
 
1797
2002
 
1798
 
def _get_info_for_log_files(revisionspec_list, file_list):
 
2003
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
1799
2004
    """Find file-ids and kinds given a list of files and a revision range.
1800
2005
 
1801
2006
    We search for files at the end of the range. If not found there,
1805
2010
    :param file_list: the list of paths given on the command line;
1806
2011
      the first of these can be a branch location or a file path,
1807
2012
      the remainder must be file paths
 
2013
    :param add_cleanup: When the branch returned is read locked,
 
2014
      an unlock call will be queued to the cleanup.
1808
2015
    :return: (branch, info_list, start_rev_info, end_rev_info) where
1809
2016
      info_list is a list of (relative_path, file_id, kind) tuples where
1810
2017
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
 
2018
      branch will be read-locked.
1811
2019
    """
1812
 
    from builtins import _get_revision_range, safe_relpath_files
 
2020
    from builtins import _get_revision_range
1813
2021
    tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
 
2022
    add_cleanup(b.lock_read().unlock)
1814
2023
    # XXX: It's damn messy converting a list of paths to relative paths when
1815
2024
    # those paths might be deleted ones, they might be on a case-insensitive
1816
2025
    # filesystem and/or they might be in silly locations (like another branch).
1820
2029
    # case of running log in a nested directory, assuming paths beyond the
1821
2030
    # first one haven't been deleted ...
1822
2031
    if tree:
1823
 
        relpaths = [path] + safe_relpath_files(tree, file_list[1:])
 
2032
        relpaths = [path] + tree.safe_relpath_files(file_list[1:])
1824
2033
    else:
1825
2034
        relpaths = [path] + file_list[1:]
1826
2035
    info_list = []
1827
2036
    start_rev_info, end_rev_info = _get_revision_range(revisionspec_list, b,
1828
2037
        "log")
 
2038
    if relpaths in ([], [u'']):
 
2039
        return b, [], start_rev_info, end_rev_info
1829
2040
    if start_rev_info is None and end_rev_info is None:
1830
2041
        if tree is None:
1831
2042
            tree = b.basis_tree()
1892
2103
 
1893
2104
 
1894
2105
properties_handler_registry = registry.Registry()
1895
 
properties_handler_registry.register_lazy("foreign",
1896
 
                                          "bzrlib.foreign",
1897
 
                                          "show_foreign_properties")
 
2106
 
 
2107
# Use the properties handlers to print out bug information if available
 
2108
def _bugs_properties_handler(revision):
 
2109
    if revision.properties.has_key('bugs'):
 
2110
        bug_lines = revision.properties['bugs'].split('\n')
 
2111
        bug_rows = [line.split(' ', 1) for line in bug_lines]
 
2112
        fixed_bug_urls = [row[0] for row in bug_rows if
 
2113
                          len(row) > 1 and row[1] == 'fixed']
 
2114
 
 
2115
        if fixed_bug_urls:
 
2116
            return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
 
2117
    return {}
 
2118
 
 
2119
properties_handler_registry.register('bugs_properties_handler',
 
2120
                                     _bugs_properties_handler)
1898
2121
 
1899
2122
 
1900
2123
# adapters which revision ids to log are filtered. When log is called, the