← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Jelmer Vernooij
  • Date: 2009-04-10 15:58:09 UTC
  • mto: This revision was merged to the branch mainline in revision 4284.
  • Revision ID: jelmer@samba.org-20090410155809-kdibzcjvp7pdb83f
Fix missing import.

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
69
69
    config,
70
70
    diff,
71
71
    errors,
72
 
    foreign,
73
72
    repository as _mod_repository,
74
73
    revision as _mod_revision,
75
74
    revisionspec,
83
82
    )
84
83
from bzrlib.osutils import (
85
84
    format_date,
86
 
    format_date_with_offset_in_original_timezone,
87
85
    get_terminal_encoding,
88
86
    re_compile_checked,
89
87
    terminal_width,
90
88
    )
91
 
from bzrlib.symbol_versioning import (
92
 
    deprecated_function,
93
 
    deprecated_in,
94
 
    )
95
89
 
96
90
 
97
91
def find_touching_revisions(branch, file_id):
109
103
    last_path = None
110
104
    revno = 1
111
105
    for revision_id in branch.revision_history():
112
 
        this_inv = branch.repository.get_inventory(revision_id)
 
106
        this_inv = branch.repository.get_revision_inventory(revision_id)
113
107
        if file_id in this_inv:
114
108
            this_ie = this_inv[file_id]
115
109
            this_path = this_inv.id2path(file_id)
308
302
 
309
303
 
310
304
class Logger(object):
311
 
    """An object that generates, formats and displays a log."""
 
305
    """An object the generates, formats and displays a log."""
312
306
 
313
307
    def __init__(self, branch, rqst):
314
308
        """Create a Logger.
389
383
        :return: An iterator yielding LogRevision objects.
390
384
        """
391
385
        rqst = self.rqst
392
 
        levels = rqst.get('levels')
393
 
        limit = rqst.get('limit')
394
 
        diff_type = rqst.get('diff_type')
395
386
        log_count = 0
396
387
        revision_iterator = self._create_log_revision_iterator()
397
388
        for revs in revision_iterator:
398
389
            for (rev_id, revno, merge_depth), rev, delta in revs:
399
390
                # 0 levels means show everything; merge_depth counts from 0
 
391
                levels = rqst.get('levels')
400
392
                if levels != 0 and merge_depth >= levels:
401
393
                    continue
402
 
                if diff_type is None:
403
 
                    diff = None
404
 
                else:
405
 
                    diff = self._format_diff(rev, rev_id, diff_type)
 
394
                diff = self._format_diff(rev, rev_id)
406
395
                yield LogRevision(rev, revno, merge_depth, delta,
407
396
                    self.rev_tag_dict.get(rev_id), diff)
 
397
                limit = rqst.get('limit')
408
398
                if limit:
409
399
                    log_count += 1
410
400
                    if log_count >= limit:
411
401
                        return
412
402
 
413
 
    def _format_diff(self, rev, rev_id, diff_type):
 
403
    def _format_diff(self, rev, rev_id):
 
404
        diff_type = self.rqst.get('diff_type')
 
405
        if diff_type is None:
 
406
            return None
414
407
        repo = self.branch.repository
415
408
        if len(rev.parent_ids) == 0:
416
409
            ancestor_id = _mod_revision.NULL_REVISION
534
527
 
535
528
 
536
529
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
537
 
                            delayed_graph_generation):
 
530
    delayed_graph_generation):
538
531
    # On large trees, generating the merge graph can take 30-60 seconds
539
532
    # so we delay doing it until a merge is detected, incrementally
540
533
    # returning initial (non-merge) revisions while we can.
541
 
 
542
 
    # The above is only true for old formats (<= 0.92), for newer formats, a
543
 
    # couple of seconds only should be needed to load the whole graph and the
544
 
    # other graph operations needed are even faster than that -- vila 100201
545
534
    initial_revisions = []
546
535
    if delayed_graph_generation:
547
536
        try:
548
 
            for rev_id, revno, depth in  _linear_view_revisions(
549
 
                branch, start_rev_id, end_rev_id):
 
537
            for rev_id, revno, depth in \
 
538
                _linear_view_revisions(branch, start_rev_id, end_rev_id):
550
539
                if _has_merges(branch, rev_id):
551
 
                    # The end_rev_id can be nested down somewhere. We need an
552
 
                    # explicit ancestry check. There is an ambiguity here as we
553
 
                    # may not raise _StartNotLinearAncestor for a revision that
554
 
                    # is an ancestor but not a *linear* one. But since we have
555
 
                    # loaded the graph to do the check (or calculate a dotted
556
 
                    # revno), we may as well accept to show the log... 
557
 
                    # -- vila 100201
558
 
                    graph = branch.repository.get_graph()
559
 
                    if not graph.is_ancestor(start_rev_id, end_rev_id):
560
 
                        raise _StartNotLinearAncestor()
561
540
                    end_rev_id = rev_id
562
541
                    break
563
542
                else:
615
594
        else:
616
595
            # not obvious
617
596
            return False
618
 
    # if either start or end is not specified then we use either the first or
619
 
    # the last revision and *they* are obvious ancestors.
620
597
    return True
621
598
 
622
599
 
684
661
                depth_adjustment = merge_depth
685
662
            if depth_adjustment:
686
663
                if merge_depth < depth_adjustment:
687
 
                    # From now on we reduce the depth adjustement, this can be
688
 
                    # surprising for users. The alternative requires two passes
689
 
                    # which breaks the fast display of the first revision
690
 
                    # though.
691
664
                    depth_adjustment = merge_depth
692
665
                merge_depth -= depth_adjustment
693
666
            yield rev_id, '.'.join(map(str, revno)), merge_depth
694
667
 
695
668
 
696
 
@deprecated_function(deprecated_in((2, 2, 0)))
697
669
def calculate_view_revisions(branch, start_revision, end_revision, direction,
698
670
        specific_fileid, generate_merge_revisions):
699
671
    """Calculate the revisions to view.
701
673
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
702
674
             a list of the same tuples.
703
675
    """
 
676
    # This method is no longer called by the main code path.
 
677
    # It is retained for API compatibility and may be deprecated
 
678
    # soon. IGC 20090116
704
679
    start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
705
680
        end_revision)
706
681
    view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
1056
1031
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
1057
1032
 
1058
1033
 
1059
 
@deprecated_function(deprecated_in((2, 2, 0)))
1060
1034
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1061
1035
    """Filter view_revisions based on revision ranges.
1062
1036
 
1071
1045
 
1072
1046
    :return: The filtered view_revisions.
1073
1047
    """
 
1048
    # This method is no longer called by the main code path.
 
1049
    # It may be removed soon. IGC 20090127
1074
1050
    if start_rev_id or end_rev_id:
1075
1051
        revision_ids = [r for r, n, d in view_revisions]
1076
1052
        if start_rev_id:
1182
1158
    return result
1183
1159
 
1184
1160
 
1185
 
@deprecated_function(deprecated_in((2, 2, 0)))
1186
1161
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1187
1162
                       include_merges=True):
1188
1163
    """Produce an iterator of revisions to show
1189
1164
    :return: an iterator of (revision_id, revno, merge_depth)
1190
1165
    (if there is no revno for a revision, None is supplied)
1191
1166
    """
 
1167
    # This method is no longer called by the main code path.
 
1168
    # It is retained for API compatibility and may be deprecated
 
1169
    # soon. IGC 20090127
1192
1170
    if not include_merges:
1193
1171
        revision_ids = mainline_revs[1:]
1194
1172
        if direction == 'reverse':
1312
1290
    preferred_levels = 0
1313
1291
 
1314
1292
    def __init__(self, to_file, show_ids=False, show_timezone='original',
1315
 
                 delta_format=None, levels=None, show_advice=False,
1316
 
                 to_exact_file=None):
 
1293
                 delta_format=None, levels=None):
1317
1294
        """Create a LogFormatter.
1318
1295
 
1319
1296
        :param to_file: the file to output to
1320
 
        :param to_exact_file: if set, gives an output stream to which 
1321
 
             non-Unicode diffs are written.
1322
1297
        :param show_ids: if True, revision-ids are to be displayed
1323
1298
        :param show_timezone: the timezone to use
1324
1299
        :param delta_format: the level of delta information to display
1325
 
          or None to leave it to the formatter to decide
 
1300
          or None to leave it u to the formatter to decide
1326
1301
        :param levels: the number of levels to display; None or -1 to
1327
1302
          let the log formatter decide.
1328
 
        :param show_advice: whether to show advice at the end of the
1329
 
          log or not
1330
1303
        """
1331
1304
        self.to_file = to_file
1332
1305
        # 'exact' stream used to show diff, it should print content 'as is'
1333
1306
        # and should not try to decode/encode it to unicode to avoid bug #328007
1334
 
        if to_exact_file is not None:
1335
 
            self.to_exact_file = to_exact_file
1336
 
        else:
1337
 
            # XXX: somewhat hacky; this assumes it's a codec writer; it's better
1338
 
            # for code that expects to get diffs to pass in the exact file
1339
 
            # stream
1340
 
            self.to_exact_file = getattr(to_file, 'stream', to_file)
 
1307
        self.to_exact_file = getattr(to_file, 'stream', to_file)
1341
1308
        self.show_ids = show_ids
1342
1309
        self.show_timezone = show_timezone
1343
1310
        if delta_format is None:
1345
1312
            delta_format = 2 # long format
1346
1313
        self.delta_format = delta_format
1347
1314
        self.levels = levels
1348
 
        self._show_advice = show_advice
1349
1315
        self._merge_count = 0
1350
1316
 
1351
1317
    def get_levels(self):
1366
1332
 
1367
1333
    def show_advice(self):
1368
1334
        """Output user advice, if any, when the log is completed."""
1369
 
        if self._show_advice and self.levels == 1 and self._merge_count > 0:
 
1335
        if self.levels == 1 and self._merge_count > 0:
1370
1336
            advice_sep = self.get_advice_separator()
1371
1337
            if advice_sep:
1372
1338
                self.to_file.write(advice_sep)
1373
1339
            self.to_file.write(
1374
 
                "Use --include-merges or -n0 to see merged revisions.\n")
 
1340
                "Use --levels 0 (or -n0) to see merged revisions.\n")
1375
1341
 
1376
1342
    def get_advice_separator(self):
1377
1343
        """Get the text separating the log from the closing advice."""
1402
1368
 
1403
1369
        If a registered handler raises an error it is propagated.
1404
1370
        """
1405
 
        for line in self.custom_properties(revision):
1406
 
            self.to_file.write("%s%s\n" % (indent, line))
1407
 
 
1408
 
    def custom_properties(self, revision):
1409
 
        """Format the custom properties returned by each registered handler.
1410
 
 
1411
 
        If a registered handler raises an error it is propagated.
1412
 
 
1413
 
        :return: a list of formatted lines (excluding trailing newlines)
1414
 
        """
1415
 
        lines = self._foreign_info_properties(revision)
1416
1371
        for key, handler in properties_handler_registry.iteritems():
1417
 
            lines.extend(self._format_properties(handler(revision)))
1418
 
        return lines
1419
 
 
1420
 
    def _foreign_info_properties(self, rev):
1421
 
        """Custom log displayer for foreign revision identifiers.
1422
 
 
1423
 
        :param rev: Revision object.
1424
 
        """
1425
 
        # Revision comes directly from a foreign repository
1426
 
        if isinstance(rev, foreign.ForeignRevision):
1427
 
            return self._format_properties(rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
1428
 
 
1429
 
        # Imported foreign revision revision ids always contain :
1430
 
        if not ":" in rev.revision_id:
1431
 
            return []
1432
 
 
1433
 
        # Revision was once imported from a foreign repository
1434
 
        try:
1435
 
            foreign_revid, mapping = \
1436
 
                foreign.foreign_vcs_registry.parse_revision_id(rev.revision_id)
1437
 
        except errors.InvalidRevisionId:
1438
 
            return []
1439
 
 
1440
 
        return self._format_properties(
1441
 
            mapping.vcs.show_foreign_revid(foreign_revid))
1442
 
 
1443
 
    def _format_properties(self, properties):
1444
 
        lines = []
1445
 
        for key, value in properties.items():
1446
 
            lines.append(key + ': ' + value)
1447
 
        return lines
 
1372
            for key, value in handler(revision).items():
 
1373
                self.to_file.write(indent + key + ': ' + value + '\n')
1448
1374
 
1449
1375
    def show_diff(self, to_file, diff, indent):
1450
1376
        for l in diff.rstrip().split('\n'):
1451
1377
            to_file.write(indent + '%s\n' % (l,))
1452
1378
 
1453
1379
 
1454
 
# Separator between revisions in long format
1455
 
_LONG_SEP = '-' * 60
1456
 
 
1457
 
 
1458
1380
class LongLogFormatter(LogFormatter):
1459
1381
 
1460
1382
    supports_merge_revisions = True
1463
1385
    supports_tags = True
1464
1386
    supports_diff = True
1465
1387
 
1466
 
    def __init__(self, *args, **kwargs):
1467
 
        super(LongLogFormatter, self).__init__(*args, **kwargs)
1468
 
        if self.show_timezone == 'original':
1469
 
            self.date_string = self._date_string_original_timezone
1470
 
        else:
1471
 
            self.date_string = self._date_string_with_timezone
1472
 
 
1473
 
    def _date_string_with_timezone(self, rev):
1474
 
        return format_date(rev.timestamp, rev.timezone or 0,
1475
 
                           self.show_timezone)
1476
 
 
1477
 
    def _date_string_original_timezone(self, rev):
1478
 
        return format_date_with_offset_in_original_timezone(rev.timestamp,
1479
 
            rev.timezone or 0)
1480
 
 
1481
1388
    def log_revision(self, revision):
1482
1389
        """Log a revision, either merged or not."""
1483
1390
        indent = '    ' * revision.merge_depth
1484
 
        lines = [_LONG_SEP]
 
1391
        to_file = self.to_file
 
1392
        to_file.write(indent + '-' * 60 + '\n')
1485
1393
        if revision.revno is not None:
1486
 
            lines.append('revno: %s%s' % (revision.revno,
 
1394
            to_file.write(indent + 'revno: %s%s\n' % (revision.revno,
1487
1395
                self.merge_marker(revision)))
1488
1396
        if revision.tags:
1489
 
            lines.append('tags: %s' % (', '.join(revision.tags)))
 
1397
            to_file.write(indent + 'tags: %s\n' % (', '.join(revision.tags)))
1490
1398
        if self.show_ids:
1491
 
            lines.append('revision-id: %s' % (revision.rev.revision_id,))
 
1399
            to_file.write(indent + 'revision-id: ' + revision.rev.revision_id)
 
1400
            to_file.write('\n')
1492
1401
            for parent_id in revision.rev.parent_ids:
1493
 
                lines.append('parent: %s' % (parent_id,))
1494
 
        lines.extend(self.custom_properties(revision.rev))
 
1402
                to_file.write(indent + 'parent: %s\n' % (parent_id,))
 
1403
        self.show_properties(revision.rev, indent)
1495
1404
 
1496
1405
        committer = revision.rev.committer
1497
1406
        authors = revision.rev.get_apparent_authors()
1498
1407
        if authors != [committer]:
1499
 
            lines.append('author: %s' % (", ".join(authors),))
1500
 
        lines.append('committer: %s' % (committer,))
 
1408
            to_file.write(indent + 'author: %s\n' % (", ".join(authors),))
 
1409
        to_file.write(indent + 'committer: %s\n' % (committer,))
1501
1410
 
1502
1411
        branch_nick = revision.rev.properties.get('branch-nick', None)
1503
1412
        if branch_nick is not None:
1504
 
            lines.append('branch nick: %s' % (branch_nick,))
1505
 
 
1506
 
        lines.append('timestamp: %s' % (self.date_string(revision.rev),))
1507
 
 
1508
 
        lines.append('message:')
 
1413
            to_file.write(indent + 'branch nick: %s\n' % (branch_nick,))
 
1414
 
 
1415
        date_str = format_date(revision.rev.timestamp,
 
1416
                               revision.rev.timezone or 0,
 
1417
                               self.show_timezone)
 
1418
        to_file.write(indent + 'timestamp: %s\n' % (date_str,))
 
1419
 
 
1420
        to_file.write(indent + 'message:\n')
1509
1421
        if not revision.rev.message:
1510
 
            lines.append('  (no message)')
 
1422
            to_file.write(indent + '  (no message)\n')
1511
1423
        else:
1512
1424
            message = revision.rev.message.rstrip('\r\n')
1513
1425
            for l in message.split('\n'):
1514
 
                lines.append('  %s' % (l,))
1515
 
 
1516
 
        # Dump the output, appending the delta and diff if requested
1517
 
        to_file = self.to_file
1518
 
        to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
 
1426
                to_file.write(indent + '  %s\n' % (l,))
1519
1427
        if revision.delta is not None:
1520
1428
            # We don't respect delta_format for compatibility
1521
1429
            revision.delta.show(to_file, self.show_ids, indent=indent,
1522
1430
                                short_status=False)
1523
1431
        if revision.diff is not None:
1524
1432
            to_file.write(indent + 'diff:\n')
1525
 
            to_file.flush()
1526
1433
            # Note: we explicitly don't indent the diff (relative to the
1527
1434
            # revision information) so that the output can be fed to patch -p0
1528
1435
            self.show_diff(self.to_exact_file, revision.diff, indent)
1529
 
            self.to_exact_file.flush()
1530
1436
 
1531
1437
    def get_advice_separator(self):
1532
1438
        """Get the text separating the log from the closing advice."""
1603
1509
 
1604
1510
    def __init__(self, *args, **kwargs):
1605
1511
        super(LineLogFormatter, self).__init__(*args, **kwargs)
1606
 
        width = terminal_width()
1607
 
        if width is not None:
1608
 
            # we need one extra space for terminals that wrap on last char
1609
 
            width = width - 1
1610
 
        self._max_chars = width
 
1512
        self._max_chars = terminal_width() - 1
1611
1513
 
1612
1514
    def truncate(self, str, max_len):
1613
 
        if max_len is None or len(str) <= max_len:
 
1515
        if len(str) <= max_len:
1614
1516
            return str
1615
 
        return str[:max_len-3] + '...'
 
1517
        return str[:max_len-3]+'...'
1616
1518
 
1617
1519
    def date_string(self, rev):
1618
1520
        return format_date(rev.timestamp, rev.timezone or 0,
1910
1812
    :return: (branch, info_list, start_rev_info, end_rev_info) where
1911
1813
      info_list is a list of (relative_path, file_id, kind) tuples where
1912
1814
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1913
 
      branch will be read-locked.
1914
1815
    """
1915
1816
    from builtins import _get_revision_range, safe_relpath_files
1916
1817
    tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
1917
 
    b.lock_read()
1918
1818
    # XXX: It's damn messy converting a list of paths to relative paths when
1919
1819
    # those paths might be deleted ones, they might be on a case-insensitive
1920
1820
    # filesystem and/or they might be in silly locations (like another branch).
1930
1830
    info_list = []
1931
1831
    start_rev_info, end_rev_info = _get_revision_range(revisionspec_list, b,
1932
1832
        "log")
1933
 
    if relpaths in ([], [u'']):
1934
 
        return b, [], start_rev_info, end_rev_info
1935
1833
    if start_rev_info is None and end_rev_info is None:
1936
1834
        if tree is None:
1937
1835
            tree = b.basis_tree()
1998
1896
 
1999
1897
 
2000
1898
properties_handler_registry = registry.Registry()
2001
 
 
2002
 
# Use the properties handlers to print out bug information if available
2003
 
def _bugs_properties_handler(revision):
2004
 
    if revision.properties.has_key('bugs'):
2005
 
        bug_lines = revision.properties['bugs'].split('\n')
2006
 
        bug_rows = [line.split(' ', 1) for line in bug_lines]
2007
 
        fixed_bug_urls = [row[0] for row in bug_rows if
2008
 
                          len(row) > 1 and row[1] == 'fixed']
2009
 
        
2010
 
        if fixed_bug_urls:
2011
 
            return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2012
 
    return {}
2013
 
 
2014
 
properties_handler_registry.register('bugs_properties_handler',
2015
 
                                     _bugs_properties_handler)
 
1899
properties_handler_registry.register_lazy("foreign",
 
1900
                                          "bzrlib.foreign",
 
1901
                                          "show_foreign_properties")
2016
1902
 
2017
1903
 
2018
1904
# adapters which revision ids to log are filtered. When log is called, the