/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-18 12:46:49 UTC
  • mto: This revision was merged to the branch mainline in revision 6386.
  • Revision ID: jelmer@samba.org-20111218124649-nf7i69ocg3k2roz3
Import absolute_import in a few places.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
17
18
 
18
19
 
19
20
"""Code to show logs of changes.
65
66
lazy_import(globals(), """
66
67
 
67
68
from bzrlib import (
68
 
    bzrdir,
69
69
    config,
 
70
    controldir,
70
71
    diff,
71
72
    errors,
72
73
    foreign,
73
74
    repository as _mod_repository,
74
75
    revision as _mod_revision,
75
76
    revisionspec,
76
 
    trace,
77
77
    tsort,
78
78
    )
 
79
from bzrlib.i18n import gettext, ngettext
79
80
""")
80
81
 
81
82
from bzrlib import (
 
83
    lazy_regex,
82
84
    registry,
83
85
    )
84
86
from bzrlib.osutils import (
85
87
    format_date,
86
88
    format_date_with_offset_in_original_timezone,
 
89
    get_diff_header_encoding,
87
90
    get_terminal_encoding,
88
 
    re_compile_checked,
89
91
    terminal_width,
90
92
    )
91
 
from bzrlib.symbol_versioning import (
92
 
    deprecated_function,
93
 
    deprecated_in,
94
 
    )
95
93
 
96
94
 
97
95
def find_touching_revisions(branch, file_id):
108
106
    last_ie = None
109
107
    last_path = None
110
108
    revno = 1
111
 
    for revision_id in branch.revision_history():
 
109
    graph = branch.repository.get_graph()
 
110
    history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
 
111
        [_mod_revision.NULL_REVISION]))
 
112
    for revision_id in reversed(history):
112
113
        this_inv = branch.repository.get_inventory(revision_id)
113
 
        if file_id in this_inv:
 
114
        if this_inv.has_id(file_id):
114
115
            this_ie = this_inv[file_id]
115
116
            this_path = this_inv.id2path(file_id)
116
117
        else:
156
157
             end_revision=None,
157
158
             search=None,
158
159
             limit=None,
159
 
             show_diff=False):
 
160
             show_diff=False,
 
161
             match=None):
160
162
    """Write out human-readable log of commits to this branch.
161
163
 
162
164
    This function is being retained for backwards compatibility but
185
187
        if None or 0.
186
188
 
187
189
    :param show_diff: If True, output a diff after each revision.
 
190
 
 
191
    :param match: Dictionary of search lists to use when matching revision
 
192
      properties.
188
193
    """
189
194
    # Convert old-style parameters to new-style parameters
190
195
    if specific_fileid is not None:
214
219
    Logger(branch, rqst).show(lf)
215
220
 
216
221
 
217
 
# Note: This needs to be kept this in sync with the defaults in
 
222
# Note: This needs to be kept in sync with the defaults in
218
223
# make_log_request_dict() below
219
224
_DEFAULT_REQUEST_PARAMS = {
220
225
    'direction': 'reverse',
221
 
    'levels': 1,
 
226
    'levels': None,
222
227
    'generate_tags': True,
223
228
    'exclude_common_ancestry': False,
224
229
    '_match_using_deltas': True,
227
232
 
228
233
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
234
                          start_revision=None, end_revision=None, limit=None,
230
 
                          message_search=None, levels=1, generate_tags=True,
 
235
                          message_search=None, levels=None, generate_tags=True,
231
236
                          delta_type=None,
232
237
                          diff_type=None, _match_using_deltas=True,
233
 
                          exclude_common_ancestry=False,
 
238
                          exclude_common_ancestry=False, match=None,
 
239
                          signature=False, omit_merges=False,
234
240
                          ):
235
241
    """Convenience function for making a logging request dictionary.
236
242
 
257
263
      matching commit messages
258
264
 
259
265
    :param levels: the number of levels of revisions to
260
 
      generate; 1 for just the mainline; 0 for all levels.
 
266
      generate; 1 for just the mainline; 0 for all levels, or None for
 
267
      a sensible default.
261
268
 
262
269
    :param generate_tags: If True, include tags for matched revisions.
263
 
 
 
270
`
264
271
    :param delta_type: Either 'full', 'partial' or None.
265
272
      'full' means generate the complete delta - adds/deletes/modifies/etc;
266
273
      'partial' means filter the delta using specific_fileids;
278
285
 
279
286
    :param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
287
      range operator or as a graph difference.
 
288
 
 
289
    :param signature: show digital signature information
 
290
 
 
291
    :param match: Dictionary of list of search strings to use when filtering
 
292
      revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
 
293
      the empty string to match any of the preceding properties.
 
294
 
 
295
    :param omit_merges: If True, commits with more than one parent are
 
296
      omitted.
 
297
 
281
298
    """
 
299
    # Take care of old style message_search parameter
 
300
    if message_search:
 
301
        if match:
 
302
            if 'message' in match:
 
303
                match['message'].append(message_search)
 
304
            else:
 
305
                match['message'] = [message_search]
 
306
        else:
 
307
            match={ 'message': [message_search] }
282
308
    return {
283
309
        'direction': direction,
284
310
        'specific_fileids': specific_fileids,
285
311
        'start_revision': start_revision,
286
312
        'end_revision': end_revision,
287
313
        'limit': limit,
288
 
        'message_search': message_search,
289
314
        'levels': levels,
290
315
        'generate_tags': generate_tags,
291
316
        'delta_type': delta_type,
292
317
        'diff_type': diff_type,
293
318
        'exclude_common_ancestry': exclude_common_ancestry,
 
319
        'signature': signature,
 
320
        'match': match,
 
321
        'omit_merges': omit_merges,
294
322
        # Add 'private' attributes for features that may be deprecated
295
323
        '_match_using_deltas': _match_using_deltas,
296
324
    }
298
326
 
299
327
def _apply_log_request_defaults(rqst):
300
328
    """Apply default values to a request dictionary."""
301
 
    result = _DEFAULT_REQUEST_PARAMS
 
329
    result = _DEFAULT_REQUEST_PARAMS.copy()
302
330
    if rqst:
303
331
        result.update(rqst)
304
332
    return result
305
333
 
306
334
 
 
335
def format_signature_validity(rev_id, repo):
 
336
    """get the signature validity
 
337
 
 
338
    :param rev_id: revision id to validate
 
339
    :param repo: repository of revision
 
340
    :return: human readable string to print to log
 
341
    """
 
342
    from bzrlib import gpg
 
343
 
 
344
    gpg_strategy = gpg.GPGStrategy(None)
 
345
    result = repo.verify_revision_signature(rev_id, gpg_strategy)
 
346
    if result[0] == gpg.SIGNATURE_VALID:
 
347
        return "valid signature from {0}".format(result[1])
 
348
    if result[0] == gpg.SIGNATURE_KEY_MISSING:
 
349
        return "unknown key {0}".format(result[1])
 
350
    if result[0] == gpg.SIGNATURE_NOT_VALID:
 
351
        return "invalid signature!"
 
352
    if result[0] == gpg.SIGNATURE_NOT_SIGNED:
 
353
        return "no signature"
 
354
 
 
355
 
307
356
class LogGenerator(object):
308
357
    """A generator of log revisions."""
309
358
 
354
403
        # Tweak the LogRequest based on what the LogFormatter can handle.
355
404
        # (There's no point generating stuff if the formatter can't display it.)
356
405
        rqst = self.rqst
357
 
        rqst['levels'] = lf.get_levels()
 
406
        if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
 
407
            # user didn't specify levels, use whatever the LF can handle:
 
408
            rqst['levels'] = lf.get_levels()
 
409
 
358
410
        if not getattr(lf, 'supports_tags', False):
359
411
            rqst['generate_tags'] = False
360
412
        if not getattr(lf, 'supports_delta', False):
361
413
            rqst['delta_type'] = None
362
414
        if not getattr(lf, 'supports_diff', False):
363
415
            rqst['diff_type'] = None
 
416
        if not getattr(lf, 'supports_signatures', False):
 
417
            rqst['signature'] = False
364
418
 
365
419
        # Find and print the interesting revisions
366
420
        generator = self._generator_factory(self.branch, rqst)
370
424
 
371
425
    def _generator_factory(self, branch, rqst):
372
426
        """Make the LogGenerator object to use.
373
 
        
 
427
 
374
428
        Subclasses may wish to override this.
375
429
        """
376
430
        return _DefaultLogGenerator(branch, rqst)
400
454
        levels = rqst.get('levels')
401
455
        limit = rqst.get('limit')
402
456
        diff_type = rqst.get('diff_type')
 
457
        show_signature = rqst.get('signature')
 
458
        omit_merges = rqst.get('omit_merges')
403
459
        log_count = 0
404
460
        revision_iterator = self._create_log_revision_iterator()
405
461
        for revs in revision_iterator:
407
463
                # 0 levels means show everything; merge_depth counts from 0
408
464
                if levels != 0 and merge_depth >= levels:
409
465
                    continue
 
466
                if omit_merges and len(rev.parent_ids) > 1:
 
467
                    continue
410
468
                if diff_type is None:
411
469
                    diff = None
412
470
                else:
413
471
                    diff = self._format_diff(rev, rev_id, diff_type)
 
472
                if show_signature:
 
473
                    signature = format_signature_validity(rev_id,
 
474
                                                self.branch.repository)
 
475
                else:
 
476
                    signature = None
414
477
                yield LogRevision(rev, revno, merge_depth, delta,
415
 
                    self.rev_tag_dict.get(rev_id), diff)
 
478
                    self.rev_tag_dict.get(rev_id), diff, signature)
416
479
                if limit:
417
480
                    log_count += 1
418
481
                    if log_count >= limit:
432
495
        else:
433
496
            specific_files = None
434
497
        s = StringIO()
 
498
        path_encoding = get_diff_header_encoding()
435
499
        diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
436
 
            new_label='')
 
500
            new_label='', path_encoding=path_encoding)
437
501
        return s.getvalue()
438
502
 
439
503
    def _create_log_revision_iterator(self):
472
536
 
473
537
        # Apply the other filters
474
538
        return make_log_rev_iterator(self.branch, view_revisions,
475
 
            rqst.get('delta_type'), rqst.get('message_search'),
 
539
            rqst.get('delta_type'), rqst.get('match'),
476
540
            file_ids=rqst.get('specific_fileids'),
477
541
            direction=rqst.get('direction'))
478
542
 
491
555
            rqst.get('specific_fileids')[0], view_revisions,
492
556
            include_merges=rqst.get('levels') != 1)
493
557
        return make_log_rev_iterator(self.branch, view_revisions,
494
 
            rqst.get('delta_type'), rqst.get('message_search'))
 
558
            rqst.get('delta_type'), rqst.get('match'))
495
559
 
496
560
 
497
561
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
569
             a list of the same tuples.
506
570
    """
507
571
    if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
 
        raise errors.BzrCommandError(
509
 
            '--exclude-common-ancestry requires two different revisions')
 
572
        raise errors.BzrCommandError(gettext(
 
573
            '--exclude-common-ancestry requires two different revisions'))
510
574
    if direction not in ('reverse', 'forward'):
511
 
        raise ValueError('invalid direction %r' % direction)
 
575
        raise ValueError(gettext('invalid direction %r') % direction)
512
576
    br_revno, br_rev_id = branch.last_revision_info()
513
577
    if br_revno == 0:
514
578
        return []
517
581
        and (not generate_merge_revisions
518
582
             or not _has_merges(branch, end_rev_id))):
519
583
        # 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)
528
 
    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)))
 
584
        return  _generate_one_revision(branch, end_rev_id, br_rev_id,
 
585
                                       br_revno)
 
586
    if not generate_merge_revisions:
 
587
        try:
 
588
            # If we only want to see linear revisions, we can iterate ...
 
589
            iter_revs = _linear_view_revisions(
 
590
                branch, start_rev_id, end_rev_id,
 
591
                exclude_common_ancestry=exclude_common_ancestry)
 
592
            # If a start limit was given and it's not obviously an
 
593
            # ancestor of the end limit, check it before outputting anything
 
594
            if (direction == 'forward'
 
595
                or (start_rev_id and not _is_obvious_ancestor(
 
596
                        branch, start_rev_id, end_rev_id))):
 
597
                    iter_revs = list(iter_revs)
 
598
            if direction == 'forward':
 
599
                iter_revs = reversed(iter_revs)
 
600
            return iter_revs
 
601
        except _StartNotLinearAncestor:
 
602
            # Switch to the slower implementation that may be able to find a
 
603
            # non-obvious ancestor out of the left-hand history.
 
604
            pass
 
605
    iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
 
606
                                        direction, delayed_graph_generation,
 
607
                                        exclude_common_ancestry)
 
608
    if direction == 'forward':
 
609
        iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
534
610
    return iter_revs
535
611
 
536
612
 
539
615
        # It's the tip
540
616
        return [(br_rev_id, br_revno, 0)]
541
617
    else:
542
 
        revno = branch.revision_id_to_dotted_revno(rev_id)
543
 
        revno_str = '.'.join(str(n) for n in revno)
 
618
        revno_str = _compute_revno_str(branch, rev_id)
544
619
        return [(rev_id, revno_str, 0)]
545
620
 
546
621
 
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)
549
 
    # If a start limit was given and it's not obviously an
550
 
    # ancestor of the end limit, check it before outputting anything
551
 
    if direction == 'forward' or (start_rev_id
552
 
        and not _is_obvious_ancestor(branch, start_rev_id, end_rev_id)):
553
 
        try:
554
 
            result = list(result)
555
 
        except _StartNotLinearAncestor:
556
 
            raise errors.BzrCommandError('Start revision not found in'
557
 
                ' left-hand history of end revision.')
558
 
    return result
559
 
 
560
 
 
561
622
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
623
                            delayed_graph_generation,
563
624
                            exclude_common_ancestry=False):
572
633
    if delayed_graph_generation:
573
634
        try:
574
635
            for rev_id, revno, depth in  _linear_view_revisions(
575
 
                branch, start_rev_id, end_rev_id):
 
636
                branch, start_rev_id, end_rev_id, exclude_common_ancestry):
576
637
                if _has_merges(branch, rev_id):
577
638
                    # The end_rev_id can be nested down somewhere. We need an
578
639
                    # explicit ancestry check. There is an ambiguity here as we
599
660
        except _StartNotLinearAncestor:
600
661
            # A merge was never detected so the lower revision limit can't
601
662
            # be nested down somewhere
602
 
            raise errors.BzrCommandError('Start revision not found in'
603
 
                ' history of end revision.')
 
663
            raise errors.BzrCommandError(gettext('Start revision not found in'
 
664
                ' history of end revision.'))
604
665
 
605
666
    # We exit the loop above because we encounter a revision with merges, from
606
667
    # this revision, we need to switch to _graph_view_revisions.
623
684
    return len(parents) > 1
624
685
 
625
686
 
 
687
def _compute_revno_str(branch, rev_id):
 
688
    """Compute the revno string from a rev_id.
 
689
 
 
690
    :return: The revno string, or None if the revision is not in the supplied
 
691
        branch.
 
692
    """
 
693
    try:
 
694
        revno = branch.revision_id_to_dotted_revno(rev_id)
 
695
    except errors.NoSuchRevision:
 
696
        # The revision must be outside of this branch
 
697
        return None
 
698
    else:
 
699
        return '.'.join(str(n) for n in revno)
 
700
 
 
701
 
626
702
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
703
    """Is start_rev_id an obvious ancestor of end_rev_id?"""
628
704
    if start_rev_id and end_rev_id:
629
 
        start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
630
 
        end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
 
705
        try:
 
706
            start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
 
707
            end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
 
708
        except errors.NoSuchRevision:
 
709
            # one or both is not in the branch; not obvious
 
710
            return False
631
711
        if len(start_dotted) == 1 and len(end_dotted) == 1:
632
712
            # both on mainline
633
713
            return start_dotted[0] <= end_dotted[0]
643
723
    return True
644
724
 
645
725
 
646
 
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
 
726
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
 
727
                           exclude_common_ancestry=False):
647
728
    """Calculate a sequence of revisions to view, newest to oldest.
648
729
 
649
730
    :param start_rev_id: the lower revision-id
650
731
    :param end_rev_id: the upper revision-id
 
732
    :param exclude_common_ancestry: Whether the start_rev_id should be part of
 
733
        the iterated revisions.
651
734
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
652
735
    :raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
 
      is not found walking the left-hand history
 
736
        is not found walking the left-hand history
654
737
    """
655
738
    br_revno, br_rev_id = branch.last_revision_info()
656
739
    repo = branch.repository
 
740
    graph = repo.get_graph()
657
741
    if start_rev_id is None and end_rev_id is None:
658
742
        cur_revno = br_revno
659
 
        for revision_id in repo.iter_reverse_revision_history(br_rev_id):
 
743
        for revision_id in graph.iter_lefthand_ancestry(br_rev_id,
 
744
            (_mod_revision.NULL_REVISION,)):
660
745
            yield revision_id, str(cur_revno), 0
661
746
            cur_revno -= 1
662
747
    else:
663
748
        if end_rev_id is None:
664
749
            end_rev_id = br_rev_id
665
750
        found_start = start_rev_id is None
666
 
        for revision_id in repo.iter_reverse_revision_history(end_rev_id):
667
 
            revno = branch.revision_id_to_dotted_revno(revision_id)
668
 
            revno_str = '.'.join(str(n) for n in revno)
 
751
        for revision_id in graph.iter_lefthand_ancestry(end_rev_id,
 
752
                (_mod_revision.NULL_REVISION,)):
 
753
            revno_str = _compute_revno_str(branch, revision_id)
669
754
            if not found_start and revision_id == start_rev_id:
670
 
                yield revision_id, revno_str, 0
 
755
                if not exclude_common_ancestry:
 
756
                    yield revision_id, revno_str, 0
671
757
                found_start = True
672
758
                break
673
759
            else:
721
807
            yield rev_id, '.'.join(map(str, revno)), merge_depth
722
808
 
723
809
 
724
 
@deprecated_function(deprecated_in((2, 2, 0)))
725
 
def calculate_view_revisions(branch, start_revision, end_revision, direction,
726
 
        specific_fileid, generate_merge_revisions):
727
 
    """Calculate the revisions to view.
728
 
 
729
 
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
730
 
             a list of the same tuples.
731
 
    """
732
 
    start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
733
 
        end_revision)
734
 
    view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
735
 
        direction, generate_merge_revisions or specific_fileid))
736
 
    if specific_fileid:
737
 
        view_revisions = _filter_revisions_touching_file_id(branch,
738
 
            specific_fileid, view_revisions,
739
 
            include_merges=generate_merge_revisions)
740
 
    return _rebase_merge_depth(view_revisions)
741
 
 
742
 
 
743
810
def _rebase_merge_depth(view_revisions):
744
811
    """Adjust depths upwards so the top level is 0."""
745
812
    # If either the first or last revision have a merge_depth of 0, we're done
789
856
    return log_rev_iterator
790
857
 
791
858
 
792
 
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
 
859
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
860
    """Create a filtered iterator of log_rev_iterator matching on a regex.
794
861
 
795
862
    :param branch: The branch being logged.
796
863
    :param generate_delta: Whether to generate a delta for each revision.
797
 
    :param search: A user text search string.
 
864
    :param match: A dictionary with properties as keys and lists of strings
 
865
        as values. To match, a revision may match any of the supplied strings
 
866
        within a single property but must match at least one string for each
 
867
        property.
798
868
    :param log_rev_iterator: An input iterator containing all revisions that
799
869
        could be displayed, in lists.
800
870
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
801
871
        delta).
802
872
    """
803
 
    if search is None:
 
873
    if match is None:
804
874
        return log_rev_iterator
805
 
    searchRE = re_compile_checked(search, re.IGNORECASE,
806
 
            'log message filter')
807
 
    return _filter_message_re(searchRE, log_rev_iterator)
808
 
 
809
 
 
810
 
def _filter_message_re(searchRE, log_rev_iterator):
 
875
    searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
 
876
                for (k,v) in match.iteritems()]
 
877
    return _filter_re(searchRE, log_rev_iterator)
 
878
 
 
879
 
 
880
def _filter_re(searchRE, log_rev_iterator):
811
881
    for revs in log_rev_iterator:
812
 
        new_revs = []
813
 
        for (rev_id, revno, merge_depth), rev, delta in revs:
814
 
            if searchRE.search(rev.message):
815
 
                new_revs.append(((rev_id, revno, merge_depth), rev, delta))
816
 
        yield new_revs
817
 
 
 
882
        new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
 
883
        if new_revs:
 
884
            yield new_revs
 
885
 
 
886
def _match_filter(searchRE, rev):
 
887
    strings = {
 
888
               'message': (rev.message,),
 
889
               'committer': (rev.committer,),
 
890
               'author': (rev.get_apparent_authors()),
 
891
               'bugs': list(rev.iter_bugs())
 
892
               }
 
893
    strings[''] = [item for inner_list in strings.itervalues()
 
894
                   for item in inner_list]
 
895
    for (k,v) in searchRE:
 
896
        if k in strings and not _match_any_filter(strings[k], v):
 
897
            return False
 
898
    return True
 
899
 
 
900
def _match_any_filter(strings, res):
 
901
    return any([filter(None, map(re.search, strings)) for re in res])
818
902
 
819
903
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
904
    fileids=None, direction='reverse'):
893
977
 
894
978
def _update_fileids(delta, fileids, stop_on):
895
979
    """Update the set of file-ids to search based on file lifecycle events.
896
 
    
 
980
 
897
981
    :param fileids: a set of fileids to update
898
982
    :param stop_on: either 'add' or 'remove' - take file-ids out of the
899
983
      fileids set once their add or remove entry is detected respectively
940
1024
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
941
1025
        delta).
942
1026
    """
943
 
    repository = branch.repository
944
1027
    num = 9
945
1028
    for batch in log_rev_iterator:
946
1029
        batch = iter(batch)
995
1078
    if branch_revno != 0:
996
1079
        if (start_rev_id == _mod_revision.NULL_REVISION
997
1080
            or end_rev_id == _mod_revision.NULL_REVISION):
998
 
            raise errors.BzrCommandError('Logging revision 0 is invalid.')
 
1081
            raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
999
1082
        if start_revno > end_revno:
1000
 
            raise errors.BzrCommandError("Start revision must be older than "
1001
 
                                         "the end revision.")
 
1083
            raise errors.BzrCommandError(gettext("Start revision must be "
 
1084
                                         "older than the end revision."))
1002
1085
    return (start_rev_id, end_rev_id)
1003
1086
 
1004
1087
 
1053
1136
 
1054
1137
    if ((start_rev_id == _mod_revision.NULL_REVISION)
1055
1138
        or (end_rev_id == _mod_revision.NULL_REVISION)):
1056
 
        raise errors.BzrCommandError('Logging revision 0 is invalid.')
 
1139
        raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1057
1140
    if start_revno > end_revno:
1058
 
        raise errors.BzrCommandError("Start revision must be older than "
1059
 
                                     "the end revision.")
 
1141
        raise errors.BzrCommandError(gettext("Start revision must be older "
 
1142
                                     "than the end revision."))
1060
1143
 
1061
1144
    if end_revno < start_revno:
1062
1145
        return None, None, None, None
1063
1146
    cur_revno = branch_revno
1064
1147
    rev_nos = {}
1065
1148
    mainline_revs = []
1066
 
    for revision_id in branch.repository.iter_reverse_revision_history(
1067
 
                        branch_last_revision):
 
1149
    graph = branch.repository.get_graph()
 
1150
    for revision_id in graph.iter_lefthand_ancestry(
 
1151
            branch_last_revision, (_mod_revision.NULL_REVISION,)):
1068
1152
        if cur_revno < start_revno:
1069
1153
            # We have gone far enough, but we always add 1 more revision
1070
1154
            rev_nos[revision_id] = cur_revno
1084
1168
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
1085
1169
 
1086
1170
 
1087
 
@deprecated_function(deprecated_in((2, 2, 0)))
1088
 
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1089
 
    """Filter view_revisions based on revision ranges.
1090
 
 
1091
 
    :param view_revisions: A list of (revision_id, dotted_revno, merge_depth)
1092
 
            tuples to be filtered.
1093
 
 
1094
 
    :param start_rev_id: If not NONE specifies the first revision to be logged.
1095
 
            If NONE then all revisions up to the end_rev_id are logged.
1096
 
 
1097
 
    :param end_rev_id: If not NONE specifies the last revision to be logged.
1098
 
            If NONE then all revisions up to the end of the log are logged.
1099
 
 
1100
 
    :return: The filtered view_revisions.
1101
 
    """
1102
 
    if start_rev_id or end_rev_id:
1103
 
        revision_ids = [r for r, n, d in view_revisions]
1104
 
        if start_rev_id:
1105
 
            start_index = revision_ids.index(start_rev_id)
1106
 
        else:
1107
 
            start_index = 0
1108
 
        if start_rev_id == end_rev_id:
1109
 
            end_index = start_index
1110
 
        else:
1111
 
            if end_rev_id:
1112
 
                end_index = revision_ids.index(end_rev_id)
1113
 
            else:
1114
 
                end_index = len(view_revisions) - 1
1115
 
        # To include the revisions merged into the last revision,
1116
 
        # extend end_rev_id down to, but not including, the next rev
1117
 
        # with the same or lesser merge_depth
1118
 
        end_merge_depth = view_revisions[end_index][2]
1119
 
        try:
1120
 
            for index in xrange(end_index+1, len(view_revisions)+1):
1121
 
                if view_revisions[index][2] <= end_merge_depth:
1122
 
                    end_index = index - 1
1123
 
                    break
1124
 
        except IndexError:
1125
 
            # if the search falls off the end then log to the end as well
1126
 
            end_index = len(view_revisions) - 1
1127
 
        view_revisions = view_revisions[start_index:end_index+1]
1128
 
    return view_revisions
1129
 
 
1130
 
 
1131
1171
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
1172
    include_merges=True):
1133
1173
    r"""Return the list of revision ids which touch a given file id.
1136
1176
    This includes the revisions which directly change the file id,
1137
1177
    and the revisions which merge these changes. So if the
1138
1178
    revision graph is::
 
1179
 
1139
1180
        A-.
1140
1181
        |\ \
1141
1182
        B C E
1168
1209
    """
1169
1210
    # Lookup all possible text keys to determine which ones actually modified
1170
1211
    # the file.
 
1212
    graph = branch.repository.get_file_graph()
 
1213
    get_parent_map = graph.get_parent_map
1171
1214
    text_keys = [(file_id, rev_id) for rev_id, revno, depth in view_revisions]
1172
1215
    next_keys = None
1173
1216
    # Looking up keys in batches of 1000 can cut the time in half, as well as
1177
1220
    #       indexing layer. We might consider passing in hints as to the known
1178
1221
    #       access pattern (sparse/clustered, high success rate/low success
1179
1222
    #       rate). This particular access is clustered with a low success rate.
1180
 
    get_parent_map = branch.repository.texts.get_parent_map
1181
1223
    modified_text_revisions = set()
1182
1224
    chunk_size = 1000
1183
1225
    for start in xrange(0, len(text_keys), chunk_size):
1210
1252
    return result
1211
1253
 
1212
1254
 
1213
 
@deprecated_function(deprecated_in((2, 2, 0)))
1214
 
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1215
 
                       include_merges=True):
1216
 
    """Produce an iterator of revisions to show
1217
 
    :return: an iterator of (revision_id, revno, merge_depth)
1218
 
    (if there is no revno for a revision, None is supplied)
1219
 
    """
1220
 
    if not include_merges:
1221
 
        revision_ids = mainline_revs[1:]
1222
 
        if direction == 'reverse':
1223
 
            revision_ids.reverse()
1224
 
        for revision_id in revision_ids:
1225
 
            yield revision_id, str(rev_nos[revision_id]), 0
1226
 
        return
1227
 
    graph = branch.repository.get_graph()
1228
 
    # This asks for all mainline revisions, which means we only have to spider
1229
 
    # sideways, rather than depth history. That said, its still size-of-history
1230
 
    # and should be addressed.
1231
 
    # mainline_revisions always includes an extra revision at the beginning, so
1232
 
    # don't request it.
1233
 
    parent_map = dict(((key, value) for key, value in
1234
 
        graph.iter_ancestry(mainline_revs[1:]) if value is not None))
1235
 
    # filter out ghosts; merge_sort errors on ghosts.
1236
 
    rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
1237
 
    merge_sorted_revisions = tsort.merge_sort(
1238
 
        rev_graph,
1239
 
        mainline_revs[-1],
1240
 
        mainline_revs,
1241
 
        generate_revno=True)
1242
 
 
1243
 
    if direction == 'forward':
1244
 
        # forward means oldest first.
1245
 
        merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
1246
 
    elif direction != 'reverse':
1247
 
        raise ValueError('invalid direction %r' % direction)
1248
 
 
1249
 
    for (sequence, rev_id, merge_depth, revno, end_of_merge
1250
 
         ) in merge_sorted_revisions:
1251
 
        yield rev_id, '.'.join(map(str, revno)), merge_depth
1252
 
 
1253
 
 
1254
1255
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1256
    """Reverse revisions by depth.
1256
1257
 
1291
1292
    """
1292
1293
 
1293
1294
    def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
1294
 
                 tags=None, diff=None):
 
1295
                 tags=None, diff=None, signature=None):
1295
1296
        self.rev = rev
1296
 
        self.revno = str(revno)
 
1297
        if revno is None:
 
1298
            self.revno = None
 
1299
        else:
 
1300
            self.revno = str(revno)
1297
1301
        self.merge_depth = merge_depth
1298
1302
        self.delta = delta
1299
1303
        self.tags = tags
1300
1304
        self.diff = diff
 
1305
        self.signature = signature
1301
1306
 
1302
1307
 
1303
1308
class LogFormatter(object):
1312
1317
    to indicate which LogRevision attributes it supports:
1313
1318
 
1314
1319
    - supports_delta must be True if this log formatter supports delta.
1315
 
        Otherwise the delta attribute may not be populated.  The 'delta_format'
1316
 
        attribute describes whether the 'short_status' format (1) or the long
1317
 
        one (2) should be used.
 
1320
      Otherwise the delta attribute may not be populated.  The 'delta_format'
 
1321
      attribute describes whether the 'short_status' format (1) or the long
 
1322
      one (2) should be used.
1318
1323
 
1319
1324
    - supports_merge_revisions must be True if this log formatter supports
1320
 
        merge revisions.  If not, then only mainline revisions will be passed
1321
 
        to the formatter.
 
1325
      merge revisions.  If not, then only mainline revisions will be passed
 
1326
      to the formatter.
1322
1327
 
1323
1328
    - preferred_levels is the number of levels this formatter defaults to.
1324
 
        The default value is zero meaning display all levels.
1325
 
        This value is only relevant if supports_merge_revisions is True.
 
1329
      The default value is zero meaning display all levels.
 
1330
      This value is only relevant if supports_merge_revisions is True.
1326
1331
 
1327
1332
    - supports_tags must be True if this log formatter supports tags.
1328
 
        Otherwise the tags attribute may not be populated.
 
1333
      Otherwise the tags attribute may not be populated.
1329
1334
 
1330
1335
    - supports_diff must be True if this log formatter supports diffs.
1331
 
        Otherwise the diff attribute may not be populated.
 
1336
      Otherwise the diff attribute may not be populated.
 
1337
 
 
1338
    - supports_signatures must be True if this log formatter supports GPG
 
1339
      signatures.
1332
1340
 
1333
1341
    Plugins can register functions to show custom revision properties using
1334
1342
    the properties_handler_registry. The registered function
1335
 
    must respect the following interface description:
 
1343
    must respect the following interface description::
 
1344
 
1336
1345
        def my_show_properties(properties_dict):
1337
1346
            # code that returns a dict {'name':'value'} of the properties
1338
1347
            # to be shown
1341
1350
 
1342
1351
    def __init__(self, to_file, show_ids=False, show_timezone='original',
1343
1352
                 delta_format=None, levels=None, show_advice=False,
1344
 
                 to_exact_file=None):
 
1353
                 to_exact_file=None, author_list_handler=None):
1345
1354
        """Create a LogFormatter.
1346
1355
 
1347
1356
        :param to_file: the file to output to
1348
 
        :param to_exact_file: if set, gives an output stream to which 
 
1357
        :param to_exact_file: if set, gives an output stream to which
1349
1358
             non-Unicode diffs are written.
1350
1359
        :param show_ids: if True, revision-ids are to be displayed
1351
1360
        :param show_timezone: the timezone to use
1355
1364
          let the log formatter decide.
1356
1365
        :param show_advice: whether to show advice at the end of the
1357
1366
          log or not
 
1367
        :param author_list_handler: callable generating a list of
 
1368
          authors to display for a given revision
1358
1369
        """
1359
1370
        self.to_file = to_file
1360
1371
        # 'exact' stream used to show diff, it should print content 'as is'
1375
1386
        self.levels = levels
1376
1387
        self._show_advice = show_advice
1377
1388
        self._merge_count = 0
 
1389
        self._author_list_handler = author_list_handler
1378
1390
 
1379
1391
    def get_levels(self):
1380
1392
        """Get the number of levels to display or 0 for all."""
1399
1411
            if advice_sep:
1400
1412
                self.to_file.write(advice_sep)
1401
1413
            self.to_file.write(
1402
 
                "Use --include-merges or -n0 to see merged revisions.\n")
 
1414
                "Use --include-merged or -n0 to see merged revisions.\n")
1403
1415
 
1404
1416
    def get_advice_separator(self):
1405
1417
        """Get the text separating the log from the closing advice."""
1412
1424
        return address
1413
1425
 
1414
1426
    def short_author(self, rev):
1415
 
        name, address = config.parse_username(rev.get_apparent_authors()[0])
1416
 
        if name:
1417
 
            return name
1418
 
        return address
 
1427
        return self.authors(rev, 'first', short=True, sep=', ')
 
1428
 
 
1429
    def authors(self, rev, who, short=False, sep=None):
 
1430
        """Generate list of authors, taking --authors option into account.
 
1431
 
 
1432
        The caller has to specify the name of a author list handler,
 
1433
        as provided by the author list registry, using the ``who``
 
1434
        argument.  That name only sets a default, though: when the
 
1435
        user selected a different author list generation using the
 
1436
        ``--authors`` command line switch, as represented by the
 
1437
        ``author_list_handler`` constructor argument, that value takes
 
1438
        precedence.
 
1439
 
 
1440
        :param rev: The revision for which to generate the list of authors.
 
1441
        :param who: Name of the default handler.
 
1442
        :param short: Whether to shorten names to either name or address.
 
1443
        :param sep: What separator to use for automatic concatenation.
 
1444
        """
 
1445
        if self._author_list_handler is not None:
 
1446
            # The user did specify --authors, which overrides the default
 
1447
            author_list_handler = self._author_list_handler
 
1448
        else:
 
1449
            # The user didn't specify --authors, so we use the caller's default
 
1450
            author_list_handler = author_list_registry.get(who)
 
1451
        names = author_list_handler(rev)
 
1452
        if short:
 
1453
            for i in range(len(names)):
 
1454
                name, address = config.parse_username(names[i])
 
1455
                if name:
 
1456
                    names[i] = name
 
1457
                else:
 
1458
                    names[i] = address
 
1459
        if sep is not None:
 
1460
            names = sep.join(names)
 
1461
        return names
1419
1462
 
1420
1463
    def merge_marker(self, revision):
1421
1464
        """Get the merge marker to include in the output or '' if none."""
1491
1534
    supports_delta = True
1492
1535
    supports_tags = True
1493
1536
    supports_diff = True
 
1537
    supports_signatures = True
1494
1538
 
1495
1539
    def __init__(self, *args, **kwargs):
1496
1540
        super(LongLogFormatter, self).__init__(*args, **kwargs)
1516
1560
                self.merge_marker(revision)))
1517
1561
        if revision.tags:
1518
1562
            lines.append('tags: %s' % (', '.join(revision.tags)))
1519
 
        if self.show_ids:
 
1563
        if self.show_ids or revision.revno is None:
1520
1564
            lines.append('revision-id: %s' % (revision.rev.revision_id,))
 
1565
        if self.show_ids:
1521
1566
            for parent_id in revision.rev.parent_ids:
1522
1567
                lines.append('parent: %s' % (parent_id,))
1523
1568
        lines.extend(self.custom_properties(revision.rev))
1524
1569
 
1525
1570
        committer = revision.rev.committer
1526
 
        authors = revision.rev.get_apparent_authors()
 
1571
        authors = self.authors(revision.rev, 'all')
1527
1572
        if authors != [committer]:
1528
1573
            lines.append('author: %s' % (", ".join(authors),))
1529
1574
        lines.append('committer: %s' % (committer,))
1534
1579
 
1535
1580
        lines.append('timestamp: %s' % (self.date_string(revision.rev),))
1536
1581
 
 
1582
        if revision.signature is not None:
 
1583
            lines.append('signature: ' + revision.signature)
 
1584
 
1537
1585
        lines.append('message:')
1538
1586
        if not revision.rev.message:
1539
1587
            lines.append('  (no message)')
1548
1596
        if revision.delta is not None:
1549
1597
            # Use the standard status output to display changes
1550
1598
            from bzrlib.delta import report_delta
1551
 
            report_delta(to_file, revision.delta, short_status=False, 
 
1599
            report_delta(to_file, revision.delta, short_status=False,
1552
1600
                         show_ids=self.show_ids, indent=indent)
1553
1601
        if revision.diff is not None:
1554
1602
            to_file.write(indent + 'diff:\n')
1586
1634
        indent = '    ' * depth
1587
1635
        revno_width = self.revno_width_by_depth.get(depth)
1588
1636
        if revno_width is None:
1589
 
            if revision.revno.find('.') == -1:
 
1637
            if revision.revno is None or revision.revno.find('.') == -1:
1590
1638
                # mainline revno, e.g. 12345
1591
1639
                revno_width = 5
1592
1640
            else:
1600
1648
        if revision.tags:
1601
1649
            tags = ' {%s}' % (', '.join(revision.tags))
1602
1650
        to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1603
 
                revision.revno, self.short_author(revision.rev),
 
1651
                revision.revno or "", self.short_author(revision.rev),
1604
1652
                format_date(revision.rev.timestamp,
1605
1653
                            revision.rev.timezone or 0,
1606
1654
                            self.show_timezone, date_fmt="%Y-%m-%d",
1607
1655
                            show_offset=False),
1608
1656
                tags, self.merge_marker(revision)))
1609
1657
        self.show_properties(revision.rev, indent+offset)
1610
 
        if self.show_ids:
 
1658
        if self.show_ids or revision.revno is None:
1611
1659
            to_file.write(indent + offset + 'revision-id:%s\n'
1612
1660
                          % (revision.rev.revision_id,))
1613
1661
        if not revision.rev.message:
1620
1668
        if revision.delta is not None:
1621
1669
            # Use the standard status output to display changes
1622
1670
            from bzrlib.delta import report_delta
1623
 
            report_delta(to_file, revision.delta, 
1624
 
                         short_status=self.delta_format==1, 
 
1671
            report_delta(to_file, revision.delta,
 
1672
                         short_status=self.delta_format==1,
1625
1673
                         show_ids=self.show_ids, indent=indent + offset)
1626
1674
        if revision.diff is not None:
1627
1675
            self.show_diff(self.to_exact_file, revision.diff, '      ')
1666
1714
 
1667
1715
    def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1668
1716
        """Format log info into one string. Truncate tail of string
1669
 
        :param  revno:      revision number or None.
1670
 
                            Revision numbers counts from 1.
1671
 
        :param  rev:        revision object
1672
 
        :param  max_chars:  maximum length of resulting string
1673
 
        :param  tags:       list of tags or None
1674
 
        :param  prefix:     string to prefix each line
1675
 
        :return:            formatted truncated string
 
1717
 
 
1718
        :param revno:      revision number or None.
 
1719
                           Revision numbers counts from 1.
 
1720
        :param rev:        revision object
 
1721
        :param max_chars:  maximum length of resulting string
 
1722
        :param tags:       list of tags or None
 
1723
        :param prefix:     string to prefix each line
 
1724
        :return:           formatted truncated string
1676
1725
        """
1677
1726
        out = []
1678
1727
        if revno:
1679
1728
            # show revno only when is not None
1680
1729
            out.append("%s:" % revno)
1681
 
        out.append(self.truncate(self.short_author(rev), 20))
 
1730
        if max_chars is not None:
 
1731
            out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
 
1732
        else:
 
1733
            out.append(self.short_author(rev))
1682
1734
        out.append(self.date_string(rev))
1683
1735
        if len(rev.parent_ids) > 1:
1684
1736
            out.append('[merge]')
1703
1755
                               self.show_timezone,
1704
1756
                               date_fmt='%Y-%m-%d',
1705
1757
                               show_offset=False)
1706
 
        committer_str = revision.rev.get_apparent_authors()[0].replace (' <', '  <')
 
1758
        committer_str = self.authors(revision.rev, 'first', sep=', ')
 
1759
        committer_str = committer_str.replace(' <', '  <')
1707
1760
        to_file.write('%s  %s\n\n' % (date_str,committer_str))
1708
1761
 
1709
1762
        if revision.delta is not None and revision.delta.has_changed():
1742
1795
        return self.get(name)(*args, **kwargs)
1743
1796
 
1744
1797
    def get_default(self, branch):
1745
 
        return self.get(branch.get_config().log_format())
 
1798
        c = branch.get_config_stack()
 
1799
        return self.get(c.get('log_format'))
1746
1800
 
1747
1801
 
1748
1802
log_formatter_registry = LogFormatterRegistry()
1749
1803
 
1750
1804
 
1751
1805
log_formatter_registry.register('short', ShortLogFormatter,
1752
 
                                'Moderately short log format')
 
1806
                                'Moderately short log format.')
1753
1807
log_formatter_registry.register('long', LongLogFormatter,
1754
 
                                'Detailed log format')
 
1808
                                'Detailed log format.')
1755
1809
log_formatter_registry.register('line', LineLogFormatter,
1756
 
                                'Log format with one line per revision')
 
1810
                                'Log format with one line per revision.')
1757
1811
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1758
 
                                'Format used by GNU ChangeLog files')
 
1812
                                'Format used by GNU ChangeLog files.')
1759
1813
 
1760
1814
 
1761
1815
def register_formatter(name, formatter):
1771
1825
    try:
1772
1826
        return log_formatter_registry.make_formatter(name, *args, **kwargs)
1773
1827
    except KeyError:
1774
 
        raise errors.BzrCommandError("unknown log formatter: %r" % name)
1775
 
 
1776
 
 
1777
 
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1778
 
    # deprecated; for compatibility
1779
 
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
1780
 
    lf.show(revno, rev, delta)
 
1828
        raise errors.BzrCommandError(gettext("unknown log formatter: %r") % name)
 
1829
 
 
1830
 
 
1831
def author_list_all(rev):
 
1832
    return rev.get_apparent_authors()[:]
 
1833
 
 
1834
 
 
1835
def author_list_first(rev):
 
1836
    lst = rev.get_apparent_authors()
 
1837
    try:
 
1838
        return [lst[0]]
 
1839
    except IndexError:
 
1840
        return []
 
1841
 
 
1842
 
 
1843
def author_list_committer(rev):
 
1844
    return [rev.committer]
 
1845
 
 
1846
 
 
1847
author_list_registry = registry.Registry()
 
1848
 
 
1849
author_list_registry.register('all', author_list_all,
 
1850
                              'All authors')
 
1851
 
 
1852
author_list_registry.register('first', author_list_first,
 
1853
                              'The first author')
 
1854
 
 
1855
author_list_registry.register('committer', author_list_committer,
 
1856
                              'The committer')
1781
1857
 
1782
1858
 
1783
1859
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1848
1924
    old_revisions = set()
1849
1925
    new_history = []
1850
1926
    new_revisions = set()
1851
 
    new_iter = repository.iter_reverse_revision_history(new_revision_id)
1852
 
    old_iter = repository.iter_reverse_revision_history(old_revision_id)
 
1927
    graph = repository.get_graph()
 
1928
    new_iter = graph.iter_lefthand_ancestry(new_revision_id)
 
1929
    old_iter = graph.iter_lefthand_ancestry(old_revision_id)
1853
1930
    stop_revision = None
1854
1931
    do_old = True
1855
1932
    do_new = True
1930
2007
        lf.log_revision(lr)
1931
2008
 
1932
2009
 
1933
 
def _get_info_for_log_files(revisionspec_list, file_list):
 
2010
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
1934
2011
    """Find file-ids and kinds given a list of files and a revision range.
1935
2012
 
1936
2013
    We search for files at the end of the range. If not found there,
1940
2017
    :param file_list: the list of paths given on the command line;
1941
2018
      the first of these can be a branch location or a file path,
1942
2019
      the remainder must be file paths
 
2020
    :param add_cleanup: When the branch returned is read locked,
 
2021
      an unlock call will be queued to the cleanup.
1943
2022
    :return: (branch, info_list, start_rev_info, end_rev_info) where
1944
2023
      info_list is a list of (relative_path, file_id, kind) tuples where
1945
2024
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1946
2025
      branch will be read-locked.
1947
2026
    """
1948
 
    from builtins import _get_revision_range, safe_relpath_files
1949
 
    tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
1950
 
    b.lock_read()
 
2027
    from bzrlib.builtins import _get_revision_range
 
2028
    tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
 
2029
        file_list[0])
 
2030
    add_cleanup(b.lock_read().unlock)
1951
2031
    # XXX: It's damn messy converting a list of paths to relative paths when
1952
2032
    # those paths might be deleted ones, they might be on a case-insensitive
1953
2033
    # filesystem and/or they might be in silly locations (like another branch).
1957
2037
    # case of running log in a nested directory, assuming paths beyond the
1958
2038
    # first one haven't been deleted ...
1959
2039
    if tree:
1960
 
        relpaths = [path] + safe_relpath_files(tree, file_list[1:])
 
2040
        relpaths = [path] + tree.safe_relpath_files(file_list[1:])
1961
2041
    else:
1962
2042
        relpaths = [path] + file_list[1:]
1963
2043
    info_list = []
2041
2121
                          len(row) > 1 and row[1] == 'fixed']
2042
2122
 
2043
2123
        if fixed_bug_urls:
2044
 
            return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
 
2124
            return {ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls)):\
 
2125
                    ' '.join(fixed_bug_urls)}
2045
2126
    return {}
2046
2127
 
2047
2128
properties_handler_registry.register('bugs_properties_handler',