← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Robert Collins
  • Date: 2010-05-06 07:48:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506074822-0bsgf2j4h8jx0xkk
Added ``bzrlib.tests.matchers`` as a place to put matchers, along with
our first in-tree matcher. See the module docstring for details.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
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,
86
85
    format_date,
87
86
    format_date_with_offset_in_original_timezone,
88
87
    get_terminal_encoding,
 
88
    re_compile_checked,
89
89
    terminal_width,
90
90
    )
91
91
from bzrlib.symbol_versioning import (
432
432
        else:
433
433
            specific_files = None
434
434
        s = StringIO()
435
 
        path_encoding = osutils.get_diff_header_encoding()
436
435
        diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
437
 
            new_label='', path_encoding=path_encoding)
 
436
            new_label='')
438
437
        return s.getvalue()
439
438
 
440
439
    def _create_log_revision_iterator(self):
523
522
    elif not generate_merge_revisions:
524
523
        # If we only want to see linear revisions, we can iterate ...
525
524
        iter_revs = _generate_flat_revisions(branch, start_rev_id, end_rev_id,
526
 
                                             direction, exclude_common_ancestry)
 
525
                                             direction)
527
526
        if direction == 'forward':
528
527
            iter_revs = reversed(iter_revs)
529
528
    else:
545
544
        return [(rev_id, revno_str, 0)]
546
545
 
547
546
 
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)
 
547
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction):
 
548
    result = _linear_view_revisions(branch, start_rev_id, end_rev_id)
553
549
    # If a start limit was given and it's not obviously an
554
550
    # ancestor of the end limit, check it before outputting anything
555
551
    if direction == 'forward' or (start_rev_id
576
572
    if delayed_graph_generation:
577
573
        try:
578
574
            for rev_id, revno, depth in  _linear_view_revisions(
579
 
                branch, start_rev_id, end_rev_id, exclude_common_ancestry):
 
575
                branch, start_rev_id, end_rev_id):
580
576
                if _has_merges(branch, rev_id):
581
577
                    # The end_rev_id can be nested down somewhere. We need an
582
578
                    # explicit ancestry check. There is an ambiguity here as we
647
643
    return True
648
644
 
649
645
 
650
 
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
651
 
                           exclude_common_ancestry=False):
 
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
652
647
    """Calculate a sequence of revisions to view, newest to oldest.
653
648
 
654
649
    :param start_rev_id: the lower revision-id
655
650
    :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
651
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
659
652
    :raises _StartNotLinearAncestor: if a start_rev_id is specified but
660
 
        is not found walking the left-hand history
 
653
      is not found walking the left-hand history
661
654
    """
662
655
    br_revno, br_rev_id = branch.last_revision_info()
663
656
    repo = branch.repository
674
667
            revno = branch.revision_id_to_dotted_revno(revision_id)
675
668
            revno_str = '.'.join(str(n) for n in revno)
676
669
            if not found_start and revision_id == start_rev_id:
677
 
                if not exclude_common_ancestry:
678
 
                    yield revision_id, revno_str, 0
 
670
                yield revision_id, revno_str, 0
679
671
                found_start = True
680
672
                break
681
673
            else:
810
802
    """
811
803
    if search is None:
812
804
        return log_rev_iterator
813
 
    searchRE = re.compile(search, re.IGNORECASE)
 
805
    searchRE = re_compile_checked(search, re.IGNORECASE,
 
806
            'log message filter')
814
807
    return _filter_message_re(searchRE, log_rev_iterator)
815
808
 
816
809
 
1348
1341
 
1349
1342
    def __init__(self, to_file, show_ids=False, show_timezone='original',
1350
1343
                 delta_format=None, levels=None, show_advice=False,
1351
 
                 to_exact_file=None, author_list_handler=None):
 
1344
                 to_exact_file=None):
1352
1345
        """Create a LogFormatter.
1353
1346
 
1354
1347
        :param to_file: the file to output to
1362
1355
          let the log formatter decide.
1363
1356
        :param show_advice: whether to show advice at the end of the
1364
1357
          log or not
1365
 
        :param author_list_handler: callable generating a list of
1366
 
          authors to display for a given revision
1367
1358
        """
1368
1359
        self.to_file = to_file
1369
1360
        # 'exact' stream used to show diff, it should print content 'as is'
1384
1375
        self.levels = levels
1385
1376
        self._show_advice = show_advice
1386
1377
        self._merge_count = 0
1387
 
        self._author_list_handler = author_list_handler
1388
1378
 
1389
1379
    def get_levels(self):
1390
1380
        """Get the number of levels to display or 0 for all."""
1422
1412
        return address
1423
1413
 
1424
1414
    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
 
1415
        name, address = config.parse_username(rev.get_apparent_authors()[0])
 
1416
        if name:
 
1417
            return name
 
1418
        return address
1460
1419
 
1461
1420
    def merge_marker(self, revision):
1462
1421
        """Get the merge marker to include in the output or '' if none."""
1564
1523
        lines.extend(self.custom_properties(revision.rev))
1565
1524
 
1566
1525
        committer = revision.rev.committer
1567
 
        authors = self.authors(revision.rev, 'all')
 
1526
        authors = revision.rev.get_apparent_authors()
1568
1527
        if authors != [committer]:
1569
1528
            lines.append('author: %s' % (", ".join(authors),))
1570
1529
        lines.append('committer: %s' % (committer,))
1744
1703
                               self.show_timezone,
1745
1704
                               date_fmt='%Y-%m-%d',
1746
1705
                               show_offset=False)
1747
 
        committer_str = self.authors(revision.rev, 'first', sep=', ')
1748
 
        committer_str = committer_str.replace(' <', '  <')
 
1706
        committer_str = revision.rev.get_apparent_authors()[0].replace (' <', '  <')
1749
1707
        to_file.write('%s  %s\n\n' % (date_str,committer_str))
1750
1708
 
1751
1709
        if revision.delta is not None and revision.delta.has_changed():
1816
1774
        raise errors.BzrCommandError("unknown log formatter: %r" % name)
1817
1775
 
1818
1776
 
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
1777
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1848
1778
    # deprecated; for compatibility
1849
1779
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
2000
1930
        lf.log_revision(lr)
2001
1931
 
2002
1932
 
2003
 
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
 
1933
def _get_info_for_log_files(revisionspec_list, file_list):
2004
1934
    """Find file-ids and kinds given a list of files and a revision range.
2005
1935
 
2006
1936
    We search for files at the end of the range. If not found there,
2010
1940
    :param file_list: the list of paths given on the command line;
2011
1941
      the first of these can be a branch location or a file path,
2012
1942
      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
1943
    :return: (branch, info_list, start_rev_info, end_rev_info) where
2016
1944
      info_list is a list of (relative_path, file_id, kind) tuples where
2017
1945
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2018
1946
      branch will be read-locked.
2019
1947
    """
2020
 
    from builtins import _get_revision_range
 
1948
    from builtins import _get_revision_range, safe_relpath_files
2021
1949
    tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2022
 
    add_cleanup(b.lock_read().unlock)
 
1950
    b.lock_read()
2023
1951
    # XXX: It's damn messy converting a list of paths to relative paths when
2024
1952
    # those paths might be deleted ones, they might be on a case-insensitive
2025
1953
    # filesystem and/or they might be in silly locations (like another branch).
2029
1957
    # case of running log in a nested directory, assuming paths beyond the
2030
1958
    # first one haven't been deleted ...
2031
1959
    if tree:
2032
 
        relpaths = [path] + tree.safe_relpath_files(file_list[1:])
 
1960
        relpaths = [path] + safe_relpath_files(tree, file_list[1:])
2033
1961
    else:
2034
1962
        relpaths = [path] + file_list[1:]
2035
1963
    info_list = []