~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-19 17:53:37 UTC
  • mto: This revision was merged to the branch mainline in revision 4466.
  • Revision ID: john@arbash-meinel.com-20090619175337-uozt3bntdd48lh4z
Update time_graph to use X:1 ratios rather than 0.xxx ratios.
It is just easier to track now that the new code is much faster.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
70
70
    diff,
71
71
    errors,
72
72
    foreign,
73
 
    osutils,
74
73
    repository as _mod_repository,
75
74
    revision as _mod_revision,
76
75
    revisionspec,
84
83
    )
85
84
from bzrlib.osutils import (
86
85
    format_date,
87
 
    format_date_with_offset_in_original_timezone,
88
86
    get_terminal_encoding,
 
87
    re_compile_checked,
89
88
    terminal_width,
90
89
    )
91
 
from bzrlib.symbol_versioning import (
92
 
    deprecated_function,
93
 
    deprecated_in,
94
 
    )
95
90
 
96
91
 
97
92
def find_touching_revisions(branch, file_id):
109
104
    last_path = None
110
105
    revno = 1
111
106
    for revision_id in branch.revision_history():
112
 
        this_inv = branch.repository.get_inventory(revision_id)
 
107
        this_inv = branch.repository.get_revision_inventory(revision_id)
113
108
        if file_id in this_inv:
114
109
            this_ie = this_inv[file_id]
115
110
            this_path = this_inv.id2path(file_id)
220
215
    'direction': 'reverse',
221
216
    'levels': 1,
222
217
    'generate_tags': True,
223
 
    'exclude_common_ancestry': False,
224
218
    '_match_using_deltas': True,
225
219
    }
226
220
 
227
221
 
228
222
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
 
                          ):
 
223
    start_revision=None, end_revision=None, limit=None,
 
224
    message_search=None, levels=1, generate_tags=True, delta_type=None,
 
225
    diff_type=None, _match_using_deltas=True):
235
226
    """Convenience function for making a logging request dictionary.
236
227
 
237
228
    Using this function may make code slightly safer by ensuring
275
266
      algorithm used for matching specific_fileids. This parameter
276
267
      may be removed in the future so bzrlib client code should NOT
277
268
      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
269
    """
282
270
    return {
283
271
        'direction': direction,
290
278
        'generate_tags': generate_tags,
291
279
        'delta_type': delta_type,
292
280
        'diff_type': diff_type,
293
 
        'exclude_common_ancestry': exclude_common_ancestry,
294
281
        # Add 'private' attributes for features that may be deprecated
295
282
        '_match_using_deltas': _match_using_deltas,
296
283
    }
316
303
 
317
304
 
318
305
class Logger(object):
319
 
    """An object that generates, formats and displays a log."""
 
306
    """An object the generates, formats and displays a log."""
320
307
 
321
308
    def __init__(self, branch, rqst):
322
309
        """Create a Logger.
397
384
        :return: An iterator yielding LogRevision objects.
398
385
        """
399
386
        rqst = self.rqst
400
 
        levels = rqst.get('levels')
401
 
        limit = rqst.get('limit')
402
 
        diff_type = rqst.get('diff_type')
403
387
        log_count = 0
404
388
        revision_iterator = self._create_log_revision_iterator()
405
389
        for revs in revision_iterator:
406
390
            for (rev_id, revno, merge_depth), rev, delta in revs:
407
391
                # 0 levels means show everything; merge_depth counts from 0
 
392
                levels = rqst.get('levels')
408
393
                if levels != 0 and merge_depth >= levels:
409
394
                    continue
410
 
                if diff_type is None:
411
 
                    diff = None
412
 
                else:
413
 
                    diff = self._format_diff(rev, rev_id, diff_type)
 
395
                diff = self._format_diff(rev, rev_id)
414
396
                yield LogRevision(rev, revno, merge_depth, delta,
415
397
                    self.rev_tag_dict.get(rev_id), diff)
 
398
                limit = rqst.get('limit')
416
399
                if limit:
417
400
                    log_count += 1
418
401
                    if log_count >= limit:
419
402
                        return
420
403
 
421
 
    def _format_diff(self, rev, rev_id, diff_type):
 
404
    def _format_diff(self, rev, rev_id):
 
405
        diff_type = self.rqst.get('diff_type')
 
406
        if diff_type is None:
 
407
            return None
422
408
        repo = self.branch.repository
423
409
        if len(rev.parent_ids) == 0:
424
410
            ancestor_id = _mod_revision.NULL_REVISION
432
418
        else:
433
419
            specific_files = None
434
420
        s = StringIO()
435
 
        path_encoding = osutils.get_diff_header_encoding()
436
421
        diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
437
 
            new_label='', path_encoding=path_encoding)
 
422
            new_label='')
438
423
        return s.getvalue()
439
424
 
440
425
    def _create_log_revision_iterator(self):
464
449
        generate_merge_revisions = rqst.get('levels') != 1
465
450
        delayed_graph_generation = not rqst.get('specific_fileids') and (
466
451
                rqst.get('limit') or self.start_rev_id or self.end_rev_id)
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'))
 
452
        view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
 
453
            self.end_rev_id, rqst.get('direction'), generate_merge_revisions,
 
454
            delayed_graph_generation=delayed_graph_generation)
473
455
 
474
456
        # Apply the other filters
475
457
        return make_log_rev_iterator(self.branch, view_revisions,
482
464
        # Note that we always generate the merge revisions because
483
465
        # filter_revisions_touching_file_id() requires them ...
484
466
        rqst = self.rqst
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'))
 
467
        view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
 
468
            self.end_rev_id, rqst.get('direction'), True)
489
469
        if not isinstance(view_revisions, list):
490
470
            view_revisions = list(view_revisions)
491
471
        view_revisions = _filter_revisions_touching_file_id(self.branch,
496
476
 
497
477
 
498
478
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
499
 
                         generate_merge_revisions,
500
 
                         delayed_graph_generation=False,
501
 
                         exclude_common_ancestry=False,
502
 
                         ):
 
479
    generate_merge_revisions, delayed_graph_generation=False):
503
480
    """Calculate the revisions to view.
504
481
 
505
482
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
506
483
             a list of the same tuples.
507
484
    """
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)
513
485
    br_revno, br_rev_id = branch.last_revision_info()
514
486
    if br_revno == 0:
515
487
        return []
516
488
 
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)
 
489
    # If a single revision is requested, check we can handle it
 
490
    generate_single_revision = (end_rev_id and start_rev_id == end_rev_id and
 
491
        (not generate_merge_revisions or not _has_merges(branch, end_rev_id)))
 
492
    if generate_single_revision:
 
493
        return _generate_one_revision(branch, end_rev_id, br_rev_id, br_revno)
 
494
 
 
495
    # If we only want to see linear revisions, we can iterate ...
 
496
    if not generate_merge_revisions:
 
497
        return _generate_flat_revisions(branch, start_rev_id, end_rev_id,
 
498
            direction)
529
499
    else:
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
 
500
        return _generate_all_revisions(branch, start_rev_id, end_rev_id,
 
501
            direction, delayed_graph_generation)
536
502
 
537
503
 
538
504
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):
545
511
        return [(rev_id, revno_str, 0)]
546
512
 
547
513
 
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)
 
514
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction):
 
515
    result = _linear_view_revisions(branch, start_rev_id, end_rev_id)
553
516
    # If a start limit was given and it's not obviously an
554
517
    # ancestor of the end limit, check it before outputting anything
555
518
    if direction == 'forward' or (start_rev_id
559
522
        except _StartNotLinearAncestor:
560
523
            raise errors.BzrCommandError('Start revision not found in'
561
524
                ' left-hand history of end revision.')
 
525
    if direction == 'forward':
 
526
        result = reversed(result)
562
527
    return result
563
528
 
564
529
 
565
530
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
566
 
                            delayed_graph_generation,
567
 
                            exclude_common_ancestry=False):
 
531
    delayed_graph_generation):
568
532
    # On large trees, generating the merge graph can take 30-60 seconds
569
533
    # so we delay doing it until a merge is detected, incrementally
570
534
    # 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
575
535
    initial_revisions = []
576
536
    if delayed_graph_generation:
577
537
        try:
578
 
            for rev_id, revno, depth in  _linear_view_revisions(
579
 
                branch, start_rev_id, end_rev_id, exclude_common_ancestry):
 
538
            for rev_id, revno, depth in \
 
539
                _linear_view_revisions(branch, start_rev_id, end_rev_id):
580
540
                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.
596
541
                    end_rev_id = rev_id
597
542
                    break
598
543
                else:
599
544
                    initial_revisions.append((rev_id, revno, depth))
600
545
            else:
601
546
                # No merged revisions found
602
 
                return initial_revisions
 
547
                if direction == 'reverse':
 
548
                    return initial_revisions
 
549
                elif direction == 'forward':
 
550
                    return reversed(initial_revisions)
 
551
                else:
 
552
                    raise ValueError('invalid direction %r' % direction)
603
553
        except _StartNotLinearAncestor:
604
554
            # A merge was never detected so the lower revision limit can't
605
555
            # be nested down somewhere
606
556
            raise errors.BzrCommandError('Start revision not found in'
607
557
                ' history of end revision.')
608
558
 
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
 
 
612
559
    # A log including nested merges is required. If the direction is reverse,
613
560
    # we rebase the initial merge depths so that the development line is
614
561
    # shown naturally, i.e. just like it is for linear logging. We can easily
616
563
    # indented at the end seems slightly nicer in that case.
617
564
    view_revisions = chain(iter(initial_revisions),
618
565
        _graph_view_revisions(branch, start_rev_id, end_rev_id,
619
 
                              rebase_initial_depths=(direction == 'reverse'),
620
 
                              exclude_common_ancestry=exclude_common_ancestry))
621
 
    return view_revisions
 
566
        rebase_initial_depths=direction == 'reverse'))
 
567
    if direction == 'reverse':
 
568
        return view_revisions
 
569
    elif direction == 'forward':
 
570
        # Forward means oldest first, adjusting for depth.
 
571
        view_revisions = reverse_by_depth(list(view_revisions))
 
572
        return _rebase_merge_depth(view_revisions)
 
573
    else:
 
574
        raise ValueError('invalid direction %r' % direction)
622
575
 
623
576
 
624
577
def _has_merges(branch, rev_id):
642
595
        else:
643
596
            # not obvious
644
597
            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.
647
598
    return True
648
599
 
649
600
 
650
 
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
651
 
                           exclude_common_ancestry=False):
 
601
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
652
602
    """Calculate a sequence of revisions to view, newest to oldest.
653
603
 
654
604
    :param start_rev_id: the lower revision-id
655
605
    :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.
658
606
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
659
607
    :raises _StartNotLinearAncestor: if a start_rev_id is specified but
660
 
        is not found walking the left-hand history
 
608
      is not found walking the left-hand history
661
609
    """
662
610
    br_revno, br_rev_id = branch.last_revision_info()
663
611
    repo = branch.repository
674
622
            revno = branch.revision_id_to_dotted_revno(revision_id)
675
623
            revno_str = '.'.join(str(n) for n in revno)
676
624
            if not found_start and revision_id == start_rev_id:
677
 
                if not exclude_common_ancestry:
678
 
                    yield revision_id, revno_str, 0
 
625
                yield revision_id, revno_str, 0
679
626
                found_start = True
680
627
                break
681
628
            else:
686
633
 
687
634
 
688
635
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
689
 
                          rebase_initial_depths=True,
690
 
                          exclude_common_ancestry=False):
 
636
    rebase_initial_depths=True):
691
637
    """Calculate revisions to view including merges, newest to oldest.
692
638
 
693
639
    :param branch: the branch
697
643
      revision is found?
698
644
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
699
645
    """
700
 
    if exclude_common_ancestry:
701
 
        stop_rule = 'with-merges-without-common-ancestry'
702
 
    else:
703
 
        stop_rule = 'with-merges'
704
646
    view_revisions = branch.iter_merge_sorted_revisions(
705
647
        start_revision_id=end_rev_id, stop_revision_id=start_rev_id,
706
 
        stop_rule=stop_rule)
 
648
        stop_rule="with-merges")
707
649
    if not rebase_initial_depths:
708
650
        for (rev_id, merge_depth, revno, end_of_merge
709
651
             ) in view_revisions:
720
662
                depth_adjustment = merge_depth
721
663
            if depth_adjustment:
722
664
                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.
727
665
                    depth_adjustment = merge_depth
728
666
                merge_depth -= depth_adjustment
729
667
            yield rev_id, '.'.join(map(str, revno)), merge_depth
730
668
 
731
669
 
732
 
@deprecated_function(deprecated_in((2, 2, 0)))
733
670
def calculate_view_revisions(branch, start_revision, end_revision, direction,
734
671
        specific_fileid, generate_merge_revisions):
735
672
    """Calculate the revisions to view.
737
674
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
738
675
             a list of the same tuples.
739
676
    """
 
677
    # This method is no longer called by the main code path.
 
678
    # It is retained for API compatibility and may be deprecated
 
679
    # soon. IGC 20090116
740
680
    start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
741
681
        end_revision)
742
682
    view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
810
750
    """
811
751
    if search is None:
812
752
        return log_rev_iterator
813
 
    searchRE = re.compile(search, re.IGNORECASE)
 
753
    searchRE = re_compile_checked(search, re.IGNORECASE,
 
754
            'log message filter')
814
755
    return _filter_message_re(searchRE, log_rev_iterator)
815
756
 
816
757
 
1091
1032
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
1092
1033
 
1093
1034
 
1094
 
@deprecated_function(deprecated_in((2, 2, 0)))
1095
1035
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1096
1036
    """Filter view_revisions based on revision ranges.
1097
1037
 
1106
1046
 
1107
1047
    :return: The filtered view_revisions.
1108
1048
    """
 
1049
    # This method is no longer called by the main code path.
 
1050
    # It may be removed soon. IGC 20090127
1109
1051
    if start_rev_id or end_rev_id:
1110
1052
        revision_ids = [r for r, n, d in view_revisions]
1111
1053
        if start_rev_id:
1217
1159
    return result
1218
1160
 
1219
1161
 
1220
 
@deprecated_function(deprecated_in((2, 2, 0)))
1221
1162
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1222
1163
                       include_merges=True):
1223
1164
    """Produce an iterator of revisions to show
1224
1165
    :return: an iterator of (revision_id, revno, merge_depth)
1225
1166
    (if there is no revno for a revision, None is supplied)
1226
1167
    """
 
1168
    # This method is no longer called by the main code path.
 
1169
    # It is retained for API compatibility and may be deprecated
 
1170
    # soon. IGC 20090127
1227
1171
    if not include_merges:
1228
1172
        revision_ids = mainline_revs[1:]
1229
1173
        if direction == 'reverse':
1347
1291
    preferred_levels = 0
1348
1292
 
1349
1293
    def __init__(self, to_file, show_ids=False, show_timezone='original',
1350
 
                 delta_format=None, levels=None, show_advice=False,
1351
 
                 to_exact_file=None, author_list_handler=None):
 
1294
                 delta_format=None, levels=None, show_advice=False):
1352
1295
        """Create a LogFormatter.
1353
1296
 
1354
1297
        :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.
1357
1298
        :param show_ids: if True, revision-ids are to be displayed
1358
1299
        :param show_timezone: the timezone to use
1359
1300
        :param delta_format: the level of delta information to display
1362
1303
          let the log formatter decide.
1363
1304
        :param show_advice: whether to show advice at the end of the
1364
1305
          log or not
1365
 
        :param author_list_handler: callable generating a list of
1366
 
          authors to display for a given revision
1367
1306
        """
1368
1307
        self.to_file = to_file
1369
1308
        # 'exact' stream used to show diff, it should print content 'as is'
1370
1309
        # and should not try to decode/encode it to unicode to avoid bug #328007
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)
 
1310
        self.to_exact_file = getattr(to_file, 'stream', to_file)
1378
1311
        self.show_ids = show_ids
1379
1312
        self.show_timezone = show_timezone
1380
1313
        if delta_format is None:
1384
1317
        self.levels = levels
1385
1318
        self._show_advice = show_advice
1386
1319
        self._merge_count = 0
1387
 
        self._author_list_handler = author_list_handler
1388
1320
 
1389
1321
    def get_levels(self):
1390
1322
        """Get the number of levels to display or 0 for all."""
1422
1354
        return address
1423
1355
 
1424
1356
    def short_author(self, rev):
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
 
1357
        name, address = config.parse_username(rev.get_apparent_authors()[0])
 
1358
        if name:
 
1359
            return name
 
1360
        return address
1460
1361
 
1461
1362
    def merge_marker(self, revision):
1462
1363
        """Get the merge marker to include in the output or '' if none."""
1466
1367
        else:
1467
1368
            return ''
1468
1369
 
1469
 
    def show_properties(self, revision, indent):
1470
 
        """Displays the custom properties returned by each registered handler.
1471
 
 
1472
 
        If a registered handler raises an error it is propagated.
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)
1485
 
        for key, handler in properties_handler_registry.iteritems():
1486
 
            lines.extend(self._format_properties(handler(revision)))
1487
 
        return lines
1488
 
 
1489
 
    def _foreign_info_properties(self, rev):
 
1370
    def show_foreign_info(self, rev, indent):
1490
1371
        """Custom log displayer for foreign revision identifiers.
1491
1372
 
1492
1373
        :param rev: Revision object.
1493
1374
        """
1494
1375
        # Revision comes directly from a foreign repository
1495
1376
        if isinstance(rev, foreign.ForeignRevision):
1496
 
            return self._format_properties(
1497
 
                rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
 
1377
            self._write_properties(indent, rev.mapping.vcs.show_foreign_revid(
 
1378
                rev.foreign_revid))
 
1379
            return
1498
1380
 
1499
1381
        # Imported foreign revision revision ids always contain :
1500
1382
        if not ":" in rev.revision_id:
1501
 
            return []
 
1383
            return
1502
1384
 
1503
1385
        # Revision was once imported from a foreign repository
1504
1386
        try:
1505
1387
            foreign_revid, mapping = \
1506
1388
                foreign.foreign_vcs_registry.parse_revision_id(rev.revision_id)
1507
1389
        except errors.InvalidRevisionId:
1508
 
            return []
 
1390
            return
1509
1391
 
1510
 
        return self._format_properties(
 
1392
        self._write_properties(indent, 
1511
1393
            mapping.vcs.show_foreign_revid(foreign_revid))
1512
1394
 
1513
 
    def _format_properties(self, properties):
1514
 
        lines = []
 
1395
    def show_properties(self, revision, indent):
 
1396
        """Displays the custom properties returned by each registered handler.
 
1397
 
 
1398
        If a registered handler raises an error it is propagated.
 
1399
        """
 
1400
        for key, handler in properties_handler_registry.iteritems():
 
1401
            self._write_properties(indent, handler(revision))
 
1402
 
 
1403
    def _write_properties(self, indent, properties):
1515
1404
        for key, value in properties.items():
1516
 
            lines.append(key + ': ' + value)
1517
 
        return lines
 
1405
            self.to_file.write(indent + key + ': ' + value + '\n')
1518
1406
 
1519
1407
    def show_diff(self, to_file, diff, indent):
1520
1408
        for l in diff.rstrip().split('\n'):
1521
1409
            to_file.write(indent + '%s\n' % (l,))
1522
1410
 
1523
1411
 
1524
 
# Separator between revisions in long format
1525
 
_LONG_SEP = '-' * 60
1526
 
 
1527
 
 
1528
1412
class LongLogFormatter(LogFormatter):
1529
1413
 
1530
1414
    supports_merge_revisions = True
1533
1417
    supports_tags = True
1534
1418
    supports_diff = True
1535
1419
 
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
 
 
1551
1420
    def log_revision(self, revision):
1552
1421
        """Log a revision, either merged or not."""
1553
1422
        indent = '    ' * revision.merge_depth
1554
 
        lines = [_LONG_SEP]
 
1423
        to_file = self.to_file
 
1424
        to_file.write(indent + '-' * 60 + '\n')
1555
1425
        if revision.revno is not None:
1556
 
            lines.append('revno: %s%s' % (revision.revno,
 
1426
            to_file.write(indent + 'revno: %s%s\n' % (revision.revno,
1557
1427
                self.merge_marker(revision)))
1558
1428
        if revision.tags:
1559
 
            lines.append('tags: %s' % (', '.join(revision.tags)))
 
1429
            to_file.write(indent + 'tags: %s\n' % (', '.join(revision.tags)))
1560
1430
        if self.show_ids:
1561
 
            lines.append('revision-id: %s' % (revision.rev.revision_id,))
 
1431
            to_file.write(indent + 'revision-id: ' + revision.rev.revision_id)
 
1432
            to_file.write('\n')
1562
1433
            for parent_id in revision.rev.parent_ids:
1563
 
                lines.append('parent: %s' % (parent_id,))
1564
 
        lines.extend(self.custom_properties(revision.rev))
 
1434
                to_file.write(indent + 'parent: %s\n' % (parent_id,))
 
1435
        self.show_foreign_info(revision.rev, indent)
 
1436
        self.show_properties(revision.rev, indent)
1565
1437
 
1566
1438
        committer = revision.rev.committer
1567
 
        authors = self.authors(revision.rev, 'all')
 
1439
        authors = revision.rev.get_apparent_authors()
1568
1440
        if authors != [committer]:
1569
 
            lines.append('author: %s' % (", ".join(authors),))
1570
 
        lines.append('committer: %s' % (committer,))
 
1441
            to_file.write(indent + 'author: %s\n' % (", ".join(authors),))
 
1442
        to_file.write(indent + 'committer: %s\n' % (committer,))
1571
1443
 
1572
1444
        branch_nick = revision.rev.properties.get('branch-nick', None)
1573
1445
        if branch_nick is not None:
1574
 
            lines.append('branch nick: %s' % (branch_nick,))
1575
 
 
1576
 
        lines.append('timestamp: %s' % (self.date_string(revision.rev),))
1577
 
 
1578
 
        lines.append('message:')
 
1446
            to_file.write(indent + 'branch nick: %s\n' % (branch_nick,))
 
1447
 
 
1448
        date_str = format_date(revision.rev.timestamp,
 
1449
                               revision.rev.timezone or 0,
 
1450
                               self.show_timezone)
 
1451
        to_file.write(indent + 'timestamp: %s\n' % (date_str,))
 
1452
 
 
1453
        to_file.write(indent + 'message:\n')
1579
1454
        if not revision.rev.message:
1580
 
            lines.append('  (no message)')
 
1455
            to_file.write(indent + '  (no message)\n')
1581
1456
        else:
1582
1457
            message = revision.rev.message.rstrip('\r\n')
1583
1458
            for l in message.split('\n'):
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)))
 
1459
                to_file.write(indent + '  %s\n' % (l,))
1589
1460
        if revision.delta is not None:
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)
 
1461
            # We don't respect delta_format for compatibility
 
1462
            revision.delta.show(to_file, self.show_ids, indent=indent,
 
1463
                                short_status=False)
1594
1464
        if revision.diff is not None:
1595
1465
            to_file.write(indent + 'diff:\n')
1596
 
            to_file.flush()
1597
1466
            # Note: we explicitly don't indent the diff (relative to the
1598
1467
            # revision information) so that the output can be fed to patch -p0
1599
1468
            self.show_diff(self.to_exact_file, revision.diff, indent)
1600
 
            self.to_exact_file.flush()
1601
1469
 
1602
1470
    def get_advice_separator(self):
1603
1471
        """Get the text separating the log from the closing advice."""
1647
1515
                            self.show_timezone, date_fmt="%Y-%m-%d",
1648
1516
                            show_offset=False),
1649
1517
                tags, self.merge_marker(revision)))
 
1518
        self.show_foreign_info(revision.rev, indent+offset)
1650
1519
        self.show_properties(revision.rev, indent+offset)
1651
1520
        if self.show_ids:
1652
1521
            to_file.write(indent + offset + 'revision-id:%s\n'
1659
1528
                to_file.write(indent + offset + '%s\n' % (l,))
1660
1529
 
1661
1530
        if revision.delta is not None:
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)
 
1531
            revision.delta.show(to_file, self.show_ids, indent=indent + offset,
 
1532
                                short_status=self.delta_format==1)
1667
1533
        if revision.diff is not None:
1668
1534
            self.show_diff(self.to_exact_file, revision.diff, '      ')
1669
1535
        to_file.write('\n')
1677
1543
 
1678
1544
    def __init__(self, *args, **kwargs):
1679
1545
        super(LineLogFormatter, self).__init__(*args, **kwargs)
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
 
1546
        self._max_chars = terminal_width() - 1
1685
1547
 
1686
1548
    def truncate(self, str, max_len):
1687
 
        if max_len is None or len(str) <= max_len:
 
1549
        if len(str) <= max_len:
1688
1550
            return str
1689
 
        return str[:max_len-3] + '...'
 
1551
        return str[:max_len-3]+'...'
1690
1552
 
1691
1553
    def date_string(self, rev):
1692
1554
        return format_date(rev.timestamp, rev.timezone or 0,
1744
1606
                               self.show_timezone,
1745
1607
                               date_fmt='%Y-%m-%d',
1746
1608
                               show_offset=False)
1747
 
        committer_str = self.authors(revision.rev, 'first', sep=', ')
1748
 
        committer_str = committer_str.replace(' <', '  <')
 
1609
        committer_str = revision.rev.committer.replace (' <', '  <')
1749
1610
        to_file.write('%s  %s\n\n' % (date_str,committer_str))
1750
1611
 
1751
1612
        if revision.delta is not None and revision.delta.has_changed():
1816
1677
        raise errors.BzrCommandError("unknown log formatter: %r" % name)
1817
1678
 
1818
1679
 
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
 
 
1847
1680
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1848
1681
    # deprecated; for compatibility
1849
1682
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
2000
1833
        lf.log_revision(lr)
2001
1834
 
2002
1835
 
2003
 
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
 
1836
def _get_info_for_log_files(revisionspec_list, file_list):
2004
1837
    """Find file-ids and kinds given a list of files and a revision range.
2005
1838
 
2006
1839
    We search for files at the end of the range. If not found there,
2010
1843
    :param file_list: the list of paths given on the command line;
2011
1844
      the first of these can be a branch location or a file path,
2012
1845
      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.
2015
1846
    :return: (branch, info_list, start_rev_info, end_rev_info) where
2016
1847
      info_list is a list of (relative_path, file_id, kind) tuples where
2017
1848
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2018
 
      branch will be read-locked.
2019
1849
    """
2020
 
    from builtins import _get_revision_range
 
1850
    from builtins import _get_revision_range, safe_relpath_files
2021
1851
    tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2022
 
    add_cleanup(b.lock_read().unlock)
2023
1852
    # XXX: It's damn messy converting a list of paths to relative paths when
2024
1853
    # those paths might be deleted ones, they might be on a case-insensitive
2025
1854
    # filesystem and/or they might be in silly locations (like another branch).
2029
1858
    # case of running log in a nested directory, assuming paths beyond the
2030
1859
    # first one haven't been deleted ...
2031
1860
    if tree:
2032
 
        relpaths = [path] + tree.safe_relpath_files(file_list[1:])
 
1861
        relpaths = [path] + safe_relpath_files(tree, file_list[1:])
2033
1862
    else:
2034
1863
        relpaths = [path] + file_list[1:]
2035
1864
    info_list = []
2104
1933
 
2105
1934
properties_handler_registry = registry.Registry()
2106
1935
 
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)
2121
 
 
2122
1936
 
2123
1937
# adapters which revision ids to log are filtered. When log is called, the
2124
1938
# log_rev_iterator is adapted through each of these factory methods.