← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-08 21:37:36 UTC
  • mto: This revision was merged to the branch mainline in revision 4885.
  • Revision ID: john@arbash-meinel.com-20091208213736-vje7ublg3xzp1bs2
Now that we return files directly from the working tree
the windows 'attrib' test needed to be updated.
If we used the working tree for both old and new, then the test wasn't
really testing what we expected, which was that the newly generated
content was readable.

But using basis_tree gets us that. Also, test that the content is
properly marked as readonly, and that we have available content from
the working tree.

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():
2032
1969
 
2033
1970
properties_handler_registry = registry.Registry()
2034
1971
 
2035
 
# Use the properties handlers to print out bug information if available
2036
 
def _bugs_properties_handler(revision):
2037
 
    if revision.properties.has_key('bugs'):
2038
 
        bug_lines = revision.properties['bugs'].split('\n')
2039
 
        bug_rows = [line.split(' ', 1) for line in bug_lines]
2040
 
        fixed_bug_urls = [row[0] for row in bug_rows if
2041
 
                          len(row) > 1 and row[1] == 'fixed']
2042
 
 
2043
 
        if fixed_bug_urls:
2044
 
            return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2045
 
    return {}
2046
 
 
2047
 
properties_handler_registry.register('bugs_properties_handler',
2048
 
                                     _bugs_properties_handler)
2049
 
 
2050
1972
 
2051
1973
# adapters which revision ids to log are filtered. When log is called, the
2052
1974
# log_rev_iterator is adapted through each of these factory methods.