← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

Put in place a structure for the admin-guide

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):
1345
1297
        """Create a LogFormatter.
1346
1298
 
1347
1299
        :param to_file: the file to output to
1348
 
        :param to_exact_file: if set, gives an output stream to which 
1349
 
             non-Unicode diffs are written.
1350
1300
        :param show_ids: if True, revision-ids are to be displayed
1351
1301
        :param show_timezone: the timezone to use
1352
1302
        :param delta_format: the level of delta information to display
1359
1309
        self.to_file = to_file
1360
1310
        # 'exact' stream used to show diff, it should print content 'as is'
1361
1311
        # and should not try to decode/encode it to unicode to avoid bug #328007
1362
 
        if to_exact_file is not None:
1363
 
            self.to_exact_file = to_exact_file
1364
 
        else:
1365
 
            # XXX: somewhat hacky; this assumes it's a codec writer; it's better
1366
 
            # for code that expects to get diffs to pass in the exact file
1367
 
            # stream
1368
 
            self.to_exact_file = getattr(to_file, 'stream', to_file)
 
1312
        self.to_exact_file = getattr(to_file, 'stream', to_file)
1369
1313
        self.show_ids = show_ids
1370
1314
        self.show_timezone = show_timezone
1371
1315
        if delta_format is None:
1452
1396
        """
1453
1397
        # Revision comes directly from a foreign repository
1454
1398
        if isinstance(rev, foreign.ForeignRevision):
1455
 
            return self._format_properties(
1456
 
                rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
 
1399
            return rev.mapping.vcs.show_foreign_revid(rev.foreign_revid)
1457
1400
 
1458
1401
        # Imported foreign revision revision ids always contain :
1459
1402
        if not ":" in rev.revision_id:
1546
1489
        to_file = self.to_file
1547
1490
        to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1548
1491
        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)
 
1492
            # We don't respect delta_format for compatibility
 
1493
            revision.delta.show(to_file, self.show_ids, indent=indent,
 
1494
                                short_status=False)
1553
1495
        if revision.diff is not None:
1554
1496
            to_file.write(indent + 'diff:\n')
1555
 
            to_file.flush()
1556
1497
            # Note: we explicitly don't indent the diff (relative to the
1557
1498
            # revision information) so that the output can be fed to patch -p0
1558
1499
            self.show_diff(self.to_exact_file, revision.diff, indent)
1559
 
            self.to_exact_file.flush()
1560
1500
 
1561
1501
    def get_advice_separator(self):
1562
1502
        """Get the text separating the log from the closing advice."""
1618
1558
                to_file.write(indent + offset + '%s\n' % (l,))
1619
1559
 
1620
1560
        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)
 
1561
            revision.delta.show(to_file, self.show_ids, indent=indent + offset,
 
1562
                                short_status=self.delta_format==1)
1626
1563
        if revision.diff is not None:
1627
1564
            self.show_diff(self.to_exact_file, revision.diff, '      ')
1628
1565
        to_file.write('\n')
1703
1640
                               self.show_timezone,
1704
1641
                               date_fmt='%Y-%m-%d',
1705
1642
                               show_offset=False)
1706
 
        committer_str = revision.rev.get_apparent_authors()[0].replace (' <', '  <')
 
1643
        committer_str = revision.rev.committer.replace (' <', '  <')
1707
1644
        to_file.write('%s  %s\n\n' % (date_str,committer_str))
1708
1645
 
1709
1646
        if revision.delta is not None and revision.delta.has_changed():
1930
1867
        lf.log_revision(lr)
1931
1868
 
1932
1869
 
1933
 
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
 
1870
def _get_info_for_log_files(revisionspec_list, file_list):
1934
1871
    """Find file-ids and kinds given a list of files and a revision range.
1935
1872
 
1936
1873
    We search for files at the end of the range. If not found there,
1940
1877
    :param file_list: the list of paths given on the command line;
1941
1878
      the first of these can be a branch location or a file path,
1942
1879
      the remainder must be file paths
1943
 
    :param add_cleanup: When the branch returned is read locked,
1944
 
      an unlock call will be queued to the cleanup.
1945
1880
    :return: (branch, info_list, start_rev_info, end_rev_info) where
1946
1881
      info_list is a list of (relative_path, file_id, kind) tuples where
1947
1882
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1949
1884
    """
1950
1885
    from builtins import _get_revision_range, safe_relpath_files
1951
1886
    tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
1952
 
    add_cleanup(b.lock_read().unlock)
 
1887
    b.lock_read()
1953
1888
    # XXX: It's damn messy converting a list of paths to relative paths when
1954
1889
    # those paths might be deleted ones, they might be on a case-insensitive
1955
1890
    # filesystem and/or they might be in silly locations (like another branch).
2034
1969
 
2035
1970
properties_handler_registry = registry.Registry()
2036
1971
 
2037
 
# Use the properties handlers to print out bug information if available
2038
 
def _bugs_properties_handler(revision):
2039
 
    if revision.properties.has_key('bugs'):
2040
 
        bug_lines = revision.properties['bugs'].split('\n')
2041
 
        bug_rows = [line.split(' ', 1) for line in bug_lines]
2042
 
        fixed_bug_urls = [row[0] for row in bug_rows if
2043
 
                          len(row) > 1 and row[1] == 'fixed']
2044
 
 
2045
 
        if fixed_bug_urls:
2046
 
            return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2047
 
    return {}
2048
 
 
2049
 
properties_handler_registry.register('bugs_properties_handler',
2050
 
                                     _bugs_properties_handler)
2051
 
 
2052
1972
 
2053
1973
# adapters which revision ids to log are filtered. When log is called, the
2054
1974
# log_rev_iterator is adapted through each of these factory methods.