/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 breezy/log.py

  • Committer: Jelmer Vernooij
  • Date: 2018-05-07 12:48:12 UTC
  • mfrom: (6953 work)
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@jelmer.uk-20180507124812-gofxbzy2bmcrucc3
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/log.py
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
 
 
18
 
 
19
17
"""Code to show logs of changes.
20
18
 
21
19
Various flavors of log can be produced:
49
47
all the changes since the previous revision that touched hello.c.
50
48
"""
51
49
 
 
50
from __future__ import absolute_import
 
51
 
52
52
import codecs
53
 
from cStringIO import StringIO
54
 
from itertools import (
55
 
    chain,
56
 
    izip,
57
 
    )
 
53
import itertools
58
54
import re
59
55
import sys
60
56
from warnings import (
61
57
    warn,
62
58
    )
63
59
 
64
 
from bzrlib.lazy_import import lazy_import
 
60
from .lazy_import import lazy_import
65
61
lazy_import(globals(), """
66
62
 
67
 
from bzrlib import (
68
 
    bzrdir,
 
63
from breezy import (
69
64
    config,
 
65
    controldir,
70
66
    diff,
71
 
    errors,
72
67
    foreign,
73
68
    repository as _mod_repository,
74
69
    revision as _mod_revision,
75
 
    revisionspec,
76
 
    trace,
77
70
    tsort,
78
71
    )
 
72
from breezy.i18n import gettext, ngettext
79
73
""")
80
74
 
81
 
from bzrlib import (
 
75
from . import (
 
76
    errors,
 
77
    lazy_regex,
82
78
    registry,
 
79
    revisionspec,
83
80
    )
84
 
from bzrlib.osutils import (
 
81
from .osutils import (
85
82
    format_date,
86
83
    format_date_with_offset_in_original_timezone,
 
84
    get_diff_header_encoding,
87
85
    get_terminal_encoding,
88
 
    re_compile_checked,
89
86
    terminal_width,
90
87
    )
91
 
from bzrlib.symbol_versioning import (
92
 
    deprecated_function,
93
 
    deprecated_in,
 
88
from .sixish import (
 
89
    BytesIO,
 
90
    range,
 
91
    zip,
94
92
    )
95
 
 
96
 
 
97
 
def find_touching_revisions(branch, file_id):
 
93
from .tree import find_previous_path
 
94
 
 
95
 
 
96
def find_touching_revisions(repository, last_revision, last_tree, last_path):
98
97
    """Yield a description of revisions which affect the file_id.
99
98
 
100
99
    Each returned element is (revno, revision_id, description)
105
104
    TODO: Perhaps some way to limit this to only particular revisions,
106
105
    or to traverse a non-mainline set of revisions?
107
106
    """
108
 
    last_ie = None
109
 
    last_path = None
110
 
    revno = 1
111
 
    for revision_id in branch.revision_history():
112
 
        this_inv = branch.repository.get_inventory(revision_id)
113
 
        if file_id in this_inv:
114
 
            this_ie = this_inv[file_id]
115
 
            this_path = this_inv.id2path(file_id)
116
 
        else:
117
 
            this_ie = this_path = None
 
107
    last_verifier = last_tree.get_file_verifier(last_path)
 
108
    graph = repository.get_graph()
 
109
    history = list(graph.iter_lefthand_ancestry(last_revision, []))
 
110
    revno = len(history)
 
111
    for revision_id in history:
 
112
        this_tree = repository.revision_tree(revision_id)
 
113
        this_path = find_previous_path(last_tree, this_tree, last_path)
118
114
 
119
115
        # now we know how it was last time, and how it is in this revision.
120
116
        # are those two states effectively the same or not?
121
 
 
122
 
        if not this_ie and not last_ie:
123
 
            # not present in either
124
 
            pass
125
 
        elif this_ie and not last_ie:
126
 
            yield revno, revision_id, "added " + this_path
127
 
        elif not this_ie and last_ie:
128
 
            # deleted here
129
 
            yield revno, revision_id, "deleted " + last_path
 
117
        if this_path is not None and last_path is None:
 
118
            yield revno, revision_id, "deleted " + this_path
 
119
            this_verifier = this_tree.get_file_verifier(this_path)
 
120
        elif this_path is None and last_path is not None:
 
121
            yield revno, revision_id, "added " + last_path
130
122
        elif this_path != last_path:
131
 
            yield revno, revision_id, ("renamed %s => %s" % (last_path, this_path))
132
 
        elif (this_ie.text_size != last_ie.text_size
133
 
              or this_ie.text_sha1 != last_ie.text_sha1):
134
 
            yield revno, revision_id, "modified " + this_path
 
123
            yield revno, revision_id, ("renamed %s => %s" % (this_path, last_path))
 
124
            this_verifier = this_tree.get_file_verifier(this_path)
 
125
        else:
 
126
            this_verifier = this_tree.get_file_verifier(this_path)
 
127
            if (this_verifier != last_verifier):
 
128
                yield revno, revision_id, "modified " + this_path
135
129
 
136
 
        last_ie = this_ie
 
130
        last_verifier = this_verifier
137
131
        last_path = this_path
138
 
        revno += 1
139
 
 
140
 
 
141
 
def _enumerate_history(branch):
142
 
    rh = []
143
 
    revno = 1
144
 
    for rev_id in branch.revision_history():
145
 
        rh.append((revno, rev_id))
146
 
        revno += 1
147
 
    return rh
 
132
        last_tree = this_tree
 
133
        if last_path is None:
 
134
            return
 
135
        revno -= 1
148
136
 
149
137
 
150
138
def show_log(branch,
156
144
             end_revision=None,
157
145
             search=None,
158
146
             limit=None,
159
 
             show_diff=False):
 
147
             show_diff=False,
 
148
             match=None):
160
149
    """Write out human-readable log of commits to this branch.
161
150
 
162
151
    This function is being retained for backwards compatibility but
185
174
        if None or 0.
186
175
 
187
176
    :param show_diff: If True, output a diff after each revision.
 
177
 
 
178
    :param match: Dictionary of search lists to use when matching revision
 
179
      properties.
188
180
    """
189
181
    # Convert old-style parameters to new-style parameters
190
182
    if specific_fileid is not None:
214
206
    Logger(branch, rqst).show(lf)
215
207
 
216
208
 
217
 
# Note: This needs to be kept this in sync with the defaults in
 
209
# Note: This needs to be kept in sync with the defaults in
218
210
# make_log_request_dict() below
219
211
_DEFAULT_REQUEST_PARAMS = {
220
212
    'direction': 'reverse',
221
 
    'levels': 1,
 
213
    'levels': None,
222
214
    'generate_tags': True,
223
215
    'exclude_common_ancestry': False,
224
216
    '_match_using_deltas': True,
227
219
 
228
220
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
221
                          start_revision=None, end_revision=None, limit=None,
230
 
                          message_search=None, levels=1, generate_tags=True,
 
222
                          message_search=None, levels=None, generate_tags=True,
231
223
                          delta_type=None,
232
224
                          diff_type=None, _match_using_deltas=True,
233
 
                          exclude_common_ancestry=False,
 
225
                          exclude_common_ancestry=False, match=None,
 
226
                          signature=False, omit_merges=False,
234
227
                          ):
235
228
    """Convenience function for making a logging request dictionary.
236
229
 
257
250
      matching commit messages
258
251
 
259
252
    :param levels: the number of levels of revisions to
260
 
      generate; 1 for just the mainline; 0 for all levels.
 
253
      generate; 1 for just the mainline; 0 for all levels, or None for
 
254
      a sensible default.
261
255
 
262
256
    :param generate_tags: If True, include tags for matched revisions.
263
 
 
 
257
`
264
258
    :param delta_type: Either 'full', 'partial' or None.
265
259
      'full' means generate the complete delta - adds/deletes/modifies/etc;
266
260
      'partial' means filter the delta using specific_fileids;
273
267
 
274
268
    :param _match_using_deltas: a private parameter controlling the
275
269
      algorithm used for matching specific_fileids. This parameter
276
 
      may be removed in the future so bzrlib client code should NOT
 
270
      may be removed in the future so breezy client code should NOT
277
271
      use it.
278
272
 
279
273
    :param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
274
      range operator or as a graph difference.
 
275
 
 
276
    :param signature: show digital signature information
 
277
 
 
278
    :param match: Dictionary of list of search strings to use when filtering
 
279
      revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
 
280
      the empty string to match any of the preceding properties.
 
281
 
 
282
    :param omit_merges: If True, commits with more than one parent are
 
283
      omitted.
 
284
 
281
285
    """
 
286
    # Take care of old style message_search parameter
 
287
    if message_search:
 
288
        if match:
 
289
            if 'message' in match:
 
290
                match['message'].append(message_search)
 
291
            else:
 
292
                match['message'] = [message_search]
 
293
        else:
 
294
            match={ 'message': [message_search] }
282
295
    return {
283
296
        'direction': direction,
284
297
        'specific_fileids': specific_fileids,
285
298
        'start_revision': start_revision,
286
299
        'end_revision': end_revision,
287
300
        'limit': limit,
288
 
        'message_search': message_search,
289
301
        'levels': levels,
290
302
        'generate_tags': generate_tags,
291
303
        'delta_type': delta_type,
292
304
        'diff_type': diff_type,
293
305
        'exclude_common_ancestry': exclude_common_ancestry,
 
306
        'signature': signature,
 
307
        'match': match,
 
308
        'omit_merges': omit_merges,
294
309
        # Add 'private' attributes for features that may be deprecated
295
310
        '_match_using_deltas': _match_using_deltas,
296
311
    }
298
313
 
299
314
def _apply_log_request_defaults(rqst):
300
315
    """Apply default values to a request dictionary."""
301
 
    result = _DEFAULT_REQUEST_PARAMS
 
316
    result = _DEFAULT_REQUEST_PARAMS.copy()
302
317
    if rqst:
303
318
        result.update(rqst)
304
319
    return result
305
320
 
306
321
 
 
322
def format_signature_validity(rev_id, branch):
 
323
    """get the signature validity
 
324
 
 
325
    :param rev_id: revision id to validate
 
326
    :param branch: branch of revision
 
327
    :return: human readable string to print to log
 
328
    """
 
329
    from breezy import gpg
 
330
 
 
331
    gpg_strategy = gpg.GPGStrategy(branch.get_config_stack())
 
332
    result = branch.repository.verify_revision_signature(rev_id, gpg_strategy)
 
333
    if result[0] == gpg.SIGNATURE_VALID:
 
334
        return u"valid signature from {0}".format(result[1])
 
335
    if result[0] == gpg.SIGNATURE_KEY_MISSING:
 
336
        return "unknown key {0}".format(result[1])
 
337
    if result[0] == gpg.SIGNATURE_NOT_VALID:
 
338
        return "invalid signature!"
 
339
    if result[0] == gpg.SIGNATURE_NOT_SIGNED:
 
340
        return "no signature"
 
341
 
 
342
 
307
343
class LogGenerator(object):
308
344
    """A generator of log revisions."""
309
345
 
354
390
        # Tweak the LogRequest based on what the LogFormatter can handle.
355
391
        # (There's no point generating stuff if the formatter can't display it.)
356
392
        rqst = self.rqst
357
 
        rqst['levels'] = lf.get_levels()
 
393
        if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
 
394
            # user didn't specify levels, use whatever the LF can handle:
 
395
            rqst['levels'] = lf.get_levels()
 
396
 
358
397
        if not getattr(lf, 'supports_tags', False):
359
398
            rqst['generate_tags'] = False
360
399
        if not getattr(lf, 'supports_delta', False):
361
400
            rqst['delta_type'] = None
362
401
        if not getattr(lf, 'supports_diff', False):
363
402
            rqst['diff_type'] = None
 
403
        if not getattr(lf, 'supports_signatures', False):
 
404
            rqst['signature'] = False
364
405
 
365
406
        # Find and print the interesting revisions
366
407
        generator = self._generator_factory(self.branch, rqst)
367
 
        for lr in generator.iter_log_revisions():
368
 
            lf.log_revision(lr)
 
408
        try:
 
409
            for lr in generator.iter_log_revisions():
 
410
                lf.log_revision(lr)
 
411
        except errors.GhostRevisionUnusableHere:
 
412
            raise errors.BzrCommandError(
 
413
                    gettext('Further revision history missing.'))
369
414
        lf.show_advice()
370
415
 
371
416
    def _generator_factory(self, branch, rqst):
372
417
        """Make the LogGenerator object to use.
373
 
        
 
418
 
374
419
        Subclasses may wish to override this.
375
420
        """
376
421
        return _DefaultLogGenerator(branch, rqst)
400
445
        levels = rqst.get('levels')
401
446
        limit = rqst.get('limit')
402
447
        diff_type = rqst.get('diff_type')
 
448
        show_signature = rqst.get('signature')
 
449
        omit_merges = rqst.get('omit_merges')
403
450
        log_count = 0
404
451
        revision_iterator = self._create_log_revision_iterator()
405
452
        for revs in revision_iterator:
407
454
                # 0 levels means show everything; merge_depth counts from 0
408
455
                if levels != 0 and merge_depth >= levels:
409
456
                    continue
 
457
                if omit_merges and len(rev.parent_ids) > 1:
 
458
                    continue
 
459
                if rev is None:
 
460
                    raise errors.GhostRevisionUnusableHere(rev_id)
410
461
                if diff_type is None:
411
462
                    diff = None
412
463
                else:
413
464
                    diff = self._format_diff(rev, rev_id, diff_type)
 
465
                if show_signature:
 
466
                    signature = format_signature_validity(rev_id, self.branch)
 
467
                else:
 
468
                    signature = None
414
469
                yield LogRevision(rev, revno, merge_depth, delta,
415
 
                    self.rev_tag_dict.get(rev_id), diff)
 
470
                    self.rev_tag_dict.get(rev_id), diff, signature)
416
471
                if limit:
417
472
                    log_count += 1
418
473
                    if log_count >= limit:
431
486
            specific_files = [tree_2.id2path(id) for id in file_ids]
432
487
        else:
433
488
            specific_files = None
434
 
        s = StringIO()
 
489
        s = BytesIO()
 
490
        path_encoding = get_diff_header_encoding()
435
491
        diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
436
 
            new_label='')
 
492
            new_label='', path_encoding=path_encoding)
437
493
        return s.getvalue()
438
494
 
439
495
    def _create_log_revision_iterator(self):
472
528
 
473
529
        # Apply the other filters
474
530
        return make_log_rev_iterator(self.branch, view_revisions,
475
 
            rqst.get('delta_type'), rqst.get('message_search'),
 
531
            rqst.get('delta_type'), rqst.get('match'),
476
532
            file_ids=rqst.get('specific_fileids'),
477
533
            direction=rqst.get('direction'))
478
534
 
491
547
            rqst.get('specific_fileids')[0], view_revisions,
492
548
            include_merges=rqst.get('levels') != 1)
493
549
        return make_log_rev_iterator(self.branch, view_revisions,
494
 
            rqst.get('delta_type'), rqst.get('message_search'))
 
550
            rqst.get('delta_type'), rqst.get('match'))
495
551
 
496
552
 
497
553
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
561
             a list of the same tuples.
506
562
    """
507
563
    if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
 
        raise errors.BzrCommandError(
509
 
            '--exclude-common-ancestry requires two different revisions')
 
564
        raise errors.BzrCommandError(gettext(
 
565
            '--exclude-common-ancestry requires two different revisions'))
510
566
    if direction not in ('reverse', 'forward'):
511
 
        raise ValueError('invalid direction %r' % direction)
 
567
        raise ValueError(gettext('invalid direction %r') % direction)
512
568
    br_revno, br_rev_id = branch.last_revision_info()
513
569
    if br_revno == 0:
514
570
        return []
517
573
        and (not generate_merge_revisions
518
574
             or not _has_merges(branch, end_rev_id))):
519
575
        # 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)))
 
576
        return  _generate_one_revision(branch, end_rev_id, br_rev_id,
 
577
                                       br_revno)
 
578
    if not generate_merge_revisions:
 
579
        try:
 
580
            # If we only want to see linear revisions, we can iterate ...
 
581
            iter_revs = _linear_view_revisions(
 
582
                branch, start_rev_id, end_rev_id,
 
583
                exclude_common_ancestry=exclude_common_ancestry)
 
584
            # If a start limit was given and it's not obviously an
 
585
            # ancestor of the end limit, check it before outputting anything
 
586
            if (direction == 'forward'
 
587
                or (start_rev_id and not _is_obvious_ancestor(
 
588
                        branch, start_rev_id, end_rev_id))):
 
589
                    iter_revs = list(iter_revs)
 
590
            if direction == 'forward':
 
591
                iter_revs = reversed(iter_revs)
 
592
            return iter_revs
 
593
        except _StartNotLinearAncestor:
 
594
            # Switch to the slower implementation that may be able to find a
 
595
            # non-obvious ancestor out of the left-hand history.
 
596
            pass
 
597
    iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
 
598
                                        direction, delayed_graph_generation,
 
599
                                        exclude_common_ancestry)
 
600
    if direction == 'forward':
 
601
        iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
534
602
    return iter_revs
535
603
 
536
604
 
539
607
        # It's the tip
540
608
        return [(br_rev_id, br_revno, 0)]
541
609
    else:
542
 
        revno = branch.revision_id_to_dotted_revno(rev_id)
543
 
        revno_str = '.'.join(str(n) for n in revno)
 
610
        revno_str = _compute_revno_str(branch, rev_id)
544
611
        return [(rev_id, revno_str, 0)]
545
612
 
546
613
 
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
614
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
615
                            delayed_graph_generation,
563
616
                            exclude_common_ancestry=False):
572
625
    if delayed_graph_generation:
573
626
        try:
574
627
            for rev_id, revno, depth in  _linear_view_revisions(
575
 
                branch, start_rev_id, end_rev_id):
 
628
                branch, start_rev_id, end_rev_id, exclude_common_ancestry):
576
629
                if _has_merges(branch, rev_id):
577
630
                    # The end_rev_id can be nested down somewhere. We need an
578
631
                    # explicit ancestry check. There is an ambiguity here as we
599
652
        except _StartNotLinearAncestor:
600
653
            # A merge was never detected so the lower revision limit can't
601
654
            # be nested down somewhere
602
 
            raise errors.BzrCommandError('Start revision not found in'
603
 
                ' history of end revision.')
 
655
            raise errors.BzrCommandError(gettext('Start revision not found in'
 
656
                ' history of end revision.'))
604
657
 
605
658
    # We exit the loop above because we encounter a revision with merges, from
606
659
    # this revision, we need to switch to _graph_view_revisions.
610
663
    # shown naturally, i.e. just like it is for linear logging. We can easily
611
664
    # make forward the exact opposite display, but showing the merge revisions
612
665
    # indented at the end seems slightly nicer in that case.
613
 
    view_revisions = chain(iter(initial_revisions),
 
666
    view_revisions = itertools.chain(iter(initial_revisions),
614
667
        _graph_view_revisions(branch, start_rev_id, end_rev_id,
615
668
                              rebase_initial_depths=(direction == 'reverse'),
616
669
                              exclude_common_ancestry=exclude_common_ancestry))
623
676
    return len(parents) > 1
624
677
 
625
678
 
 
679
def _compute_revno_str(branch, rev_id):
 
680
    """Compute the revno string from a rev_id.
 
681
 
 
682
    :return: The revno string, or None if the revision is not in the supplied
 
683
        branch.
 
684
    """
 
685
    try:
 
686
        revno = branch.revision_id_to_dotted_revno(rev_id)
 
687
    except errors.NoSuchRevision:
 
688
        # The revision must be outside of this branch
 
689
        return None
 
690
    else:
 
691
        return '.'.join(str(n) for n in revno)
 
692
 
 
693
 
626
694
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
695
    """Is start_rev_id an obvious ancestor of end_rev_id?"""
628
696
    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)
 
697
        try:
 
698
            start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
 
699
            end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
 
700
        except errors.NoSuchRevision:
 
701
            # one or both is not in the branch; not obvious
 
702
            return False
631
703
        if len(start_dotted) == 1 and len(end_dotted) == 1:
632
704
            # both on mainline
633
705
            return start_dotted[0] <= end_dotted[0]
643
715
    return True
644
716
 
645
717
 
646
 
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
 
718
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
 
719
                           exclude_common_ancestry=False):
647
720
    """Calculate a sequence of revisions to view, newest to oldest.
648
721
 
649
722
    :param start_rev_id: the lower revision-id
650
723
    :param end_rev_id: the upper revision-id
 
724
    :param exclude_common_ancestry: Whether the start_rev_id should be part of
 
725
        the iterated revisions.
651
726
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
 
727
        dotted_revno will be None for ghosts
652
728
    :raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
 
      is not found walking the left-hand history
 
729
        is not found walking the left-hand history
654
730
    """
655
731
    br_revno, br_rev_id = branch.last_revision_info()
656
732
    repo = branch.repository
 
733
    graph = repo.get_graph()
657
734
    if start_rev_id is None and end_rev_id is None:
658
735
        cur_revno = br_revno
659
 
        for revision_id in repo.iter_reverse_revision_history(br_rev_id):
660
 
            yield revision_id, str(cur_revno), 0
661
 
            cur_revno -= 1
 
736
        graph_iter = graph.iter_lefthand_ancestry(br_rev_id,
 
737
            (_mod_revision.NULL_REVISION,))
 
738
        while True:
 
739
            try:
 
740
                revision_id = next(graph_iter)
 
741
            except errors.RevisionNotPresent as e:
 
742
                # Oops, a ghost.
 
743
                yield e.revision_id, None, None
 
744
                break
 
745
            else:
 
746
                yield revision_id, str(cur_revno), 0
 
747
                cur_revno -= 1
662
748
    else:
663
749
        if end_rev_id is None:
664
750
            end_rev_id = br_rev_id
665
751
        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)
669
 
            if not found_start and revision_id == start_rev_id:
670
 
                yield revision_id, revno_str, 0
671
 
                found_start = True
 
752
        graph_iter = graph.iter_lefthand_ancestry(end_rev_id,
 
753
            (_mod_revision.NULL_REVISION,))
 
754
        while True:
 
755
            try:
 
756
                revision_id = next(graph_iter)
 
757
            except StopIteration:
 
758
                break
 
759
            except errors.RevisionNotPresent as e:
 
760
                # Oops, a ghost.
 
761
                yield e.revision_id, None, None
672
762
                break
673
763
            else:
674
 
                yield revision_id, revno_str, 0
675
 
        else:
676
 
            if not found_start:
677
 
                raise _StartNotLinearAncestor()
 
764
                revno_str = _compute_revno_str(branch, revision_id)
 
765
                if not found_start and revision_id == start_rev_id:
 
766
                    if not exclude_common_ancestry:
 
767
                        yield revision_id, revno_str, 0
 
768
                    found_start = True
 
769
                    break
 
770
                else:
 
771
                    yield revision_id, revno_str, 0
 
772
        if not found_start:
 
773
            raise _StartNotLinearAncestor()
678
774
 
679
775
 
680
776
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
721
817
            yield rev_id, '.'.join(map(str, revno)), merge_depth
722
818
 
723
819
 
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
820
def _rebase_merge_depth(view_revisions):
744
821
    """Adjust depths upwards so the top level is 0."""
745
822
    # If either the first or last revision have a merge_depth of 0, we're done
746
823
    if view_revisions and view_revisions[0][2] and view_revisions[-1][2]:
747
 
        min_depth = min([d for r,n,d in view_revisions])
 
824
        min_depth = min([d for r, n, d in view_revisions])
748
825
        if min_depth != 0:
749
 
            view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
 
826
            view_revisions = [(r, n, d-min_depth) for r, n, d in view_revisions]
750
827
    return view_revisions
751
828
 
752
829
 
767
844
    """
768
845
    # Convert view_revisions into (view, None, None) groups to fit with
769
846
    # the standard interface here.
770
 
    if type(view_revisions) == list:
 
847
    if isinstance(view_revisions, list):
771
848
        # A single batch conversion is faster than many incremental ones.
772
849
        # As we have all the data, do a batch conversion.
773
850
        nones = [None] * len(view_revisions)
774
 
        log_rev_iterator = iter([zip(view_revisions, nones, nones)])
 
851
        log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
775
852
    else:
776
853
        def _convert():
777
854
            for view in view_revisions:
789
866
    return log_rev_iterator
790
867
 
791
868
 
792
 
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
 
869
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
870
    """Create a filtered iterator of log_rev_iterator matching on a regex.
794
871
 
795
872
    :param branch: The branch being logged.
796
873
    :param generate_delta: Whether to generate a delta for each revision.
797
 
    :param search: A user text search string.
 
874
    :param match: A dictionary with properties as keys and lists of strings
 
875
        as values. To match, a revision may match any of the supplied strings
 
876
        within a single property but must match at least one string for each
 
877
        property.
798
878
    :param log_rev_iterator: An input iterator containing all revisions that
799
879
        could be displayed, in lists.
800
880
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
801
881
        delta).
802
882
    """
803
 
    if search is None:
 
883
    if not match:
804
884
        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):
 
885
    searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
 
886
                for k, v in match.items()]
 
887
    return _filter_re(searchRE, log_rev_iterator)
 
888
 
 
889
 
 
890
def _filter_re(searchRE, log_rev_iterator):
811
891
    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
 
 
 
892
        new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
 
893
        if new_revs:
 
894
            yield new_revs
 
895
 
 
896
def _match_filter(searchRE, rev):
 
897
    strings = {
 
898
               'message': (rev.message,),
 
899
               'committer': (rev.committer,),
 
900
               'author': (rev.get_apparent_authors()),
 
901
               'bugs': list(rev.iter_bugs())
 
902
               }
 
903
    strings[''] = [item for inner_list in strings.values()
 
904
                   for item in inner_list]
 
905
    for (k, v) in searchRE:
 
906
        if k in strings and not _match_any_filter(strings[k], v):
 
907
            return False
 
908
    return True
 
909
 
 
910
def _match_any_filter(strings, res):
 
911
    return any(re.search(s) for re in res for s in strings)
818
912
 
819
913
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
914
    fileids=None, direction='reverse'):
865
959
        new_revs = []
866
960
        if delta_type == 'full' and not check_fileids:
867
961
            deltas = repository.get_deltas_for_revisions(revisions)
868
 
            for rev, delta in izip(revs, deltas):
 
962
            for rev, delta in zip(revs, deltas):
869
963
                new_revs.append((rev[0], rev[1], delta))
870
964
        else:
871
965
            deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
872
 
            for rev, delta in izip(revs, deltas):
 
966
            for rev, delta in zip(revs, deltas):
873
967
                if check_fileids:
874
968
                    if delta is None or not delta.has_changed():
875
969
                        continue
893
987
 
894
988
def _update_fileids(delta, fileids, stop_on):
895
989
    """Update the set of file-ids to search based on file lifecycle events.
896
 
    
 
990
 
897
991
    :param fileids: a set of fileids to update
898
992
    :param stop_on: either 'add' or 'remove' - take file-ids out of the
899
993
      fileids set once their add or remove entry is detected respectively
923
1017
    for revs in log_rev_iterator:
924
1018
        # r = revision_id, n = revno, d = merge depth
925
1019
        revision_ids = [view[0] for view, _, _ in revs]
926
 
        revisions = repository.get_revisions(revision_ids)
927
 
        revs = [(rev[0], revision, rev[2]) for rev, revision in
928
 
            izip(revs, revisions)]
929
 
        yield revs
 
1020
        revisions = dict(repository.iter_revisions(revision_ids))
 
1021
        yield [(rev[0], revisions[rev[0][0]], rev[2]) for rev in revs]
930
1022
 
931
1023
 
932
1024
def _make_batch_filter(branch, generate_delta, search, log_rev_iterator):
940
1032
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
941
1033
        delta).
942
1034
    """
943
 
    repository = branch.repository
944
1035
    num = 9
945
1036
    for batch in log_rev_iterator:
946
1037
        batch = iter(batch)
995
1086
    if branch_revno != 0:
996
1087
        if (start_rev_id == _mod_revision.NULL_REVISION
997
1088
            or end_rev_id == _mod_revision.NULL_REVISION):
998
 
            raise errors.BzrCommandError('Logging revision 0 is invalid.')
 
1089
            raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
999
1090
        if start_revno > end_revno:
1000
 
            raise errors.BzrCommandError("Start revision must be older than "
1001
 
                                         "the end revision.")
 
1091
            raise errors.BzrCommandError(gettext("Start revision must be "
 
1092
                                         "older than the end revision."))
1002
1093
    return (start_rev_id, end_rev_id)
1003
1094
 
1004
1095
 
1053
1144
 
1054
1145
    if ((start_rev_id == _mod_revision.NULL_REVISION)
1055
1146
        or (end_rev_id == _mod_revision.NULL_REVISION)):
1056
 
        raise errors.BzrCommandError('Logging revision 0 is invalid.')
 
1147
        raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1057
1148
    if start_revno > end_revno:
1058
 
        raise errors.BzrCommandError("Start revision must be older than "
1059
 
                                     "the end revision.")
 
1149
        raise errors.BzrCommandError(gettext("Start revision must be older "
 
1150
                                     "than the end revision."))
1060
1151
 
1061
1152
    if end_revno < start_revno:
1062
1153
        return None, None, None, None
1063
1154
    cur_revno = branch_revno
1064
1155
    rev_nos = {}
1065
1156
    mainline_revs = []
1066
 
    for revision_id in branch.repository.iter_reverse_revision_history(
1067
 
                        branch_last_revision):
 
1157
    graph = branch.repository.get_graph()
 
1158
    for revision_id in graph.iter_lefthand_ancestry(
 
1159
            branch_last_revision, (_mod_revision.NULL_REVISION,)):
1068
1160
        if cur_revno < start_revno:
1069
1161
            # We have gone far enough, but we always add 1 more revision
1070
1162
            rev_nos[revision_id] = cur_revno
1084
1176
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
1085
1177
 
1086
1178
 
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
1179
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
1180
    include_merges=True):
1133
1181
    r"""Return the list of revision ids which touch a given file id.
1136
1184
    This includes the revisions which directly change the file id,
1137
1185
    and the revisions which merge these changes. So if the
1138
1186
    revision graph is::
 
1187
 
1139
1188
        A-.
1140
1189
        |\ \
1141
1190
        B C E
1168
1217
    """
1169
1218
    # Lookup all possible text keys to determine which ones actually modified
1170
1219
    # the file.
 
1220
    graph = branch.repository.get_file_graph()
 
1221
    get_parent_map = graph.get_parent_map
1171
1222
    text_keys = [(file_id, rev_id) for rev_id, revno, depth in view_revisions]
1172
1223
    next_keys = None
1173
1224
    # Looking up keys in batches of 1000 can cut the time in half, as well as
1177
1228
    #       indexing layer. We might consider passing in hints as to the known
1178
1229
    #       access pattern (sparse/clustered, high success rate/low success
1179
1230
    #       rate). This particular access is clustered with a low success rate.
1180
 
    get_parent_map = branch.repository.texts.get_parent_map
1181
1231
    modified_text_revisions = set()
1182
1232
    chunk_size = 1000
1183
 
    for start in xrange(0, len(text_keys), chunk_size):
 
1233
    for start in range(0, len(text_keys), chunk_size):
1184
1234
        next_keys = text_keys[start:start + chunk_size]
1185
1235
        # Only keep the revision_id portion of the key
1186
1236
        modified_text_revisions.update(
1201
1251
 
1202
1252
        if rev_id in modified_text_revisions:
1203
1253
            # This needs to be logged, along with the extra revisions
1204
 
            for idx in xrange(len(current_merge_stack)):
 
1254
            for idx in range(len(current_merge_stack)):
1205
1255
                node = current_merge_stack[idx]
1206
1256
                if node is not None:
1207
1257
                    if include_merges or node[2] == 0:
1210
1260
    return result
1211
1261
 
1212
1262
 
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
1263
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1264
    """Reverse revisions by depth.
1256
1265
 
1291
1300
    """
1292
1301
 
1293
1302
    def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
1294
 
                 tags=None, diff=None):
 
1303
                 tags=None, diff=None, signature=None):
1295
1304
        self.rev = rev
1296
 
        self.revno = str(revno)
 
1305
        if revno is None:
 
1306
            self.revno = None
 
1307
        else:
 
1308
            self.revno = str(revno)
1297
1309
        self.merge_depth = merge_depth
1298
1310
        self.delta = delta
1299
1311
        self.tags = tags
1300
1312
        self.diff = diff
 
1313
        self.signature = signature
1301
1314
 
1302
1315
 
1303
1316
class LogFormatter(object):
1312
1325
    to indicate which LogRevision attributes it supports:
1313
1326
 
1314
1327
    - 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.
 
1328
      Otherwise the delta attribute may not be populated.  The 'delta_format'
 
1329
      attribute describes whether the 'short_status' format (1) or the long
 
1330
      one (2) should be used.
1318
1331
 
1319
1332
    - 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.
 
1333
      merge revisions.  If not, then only mainline revisions will be passed
 
1334
      to the formatter.
1322
1335
 
1323
1336
    - 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.
 
1337
      The default value is zero meaning display all levels.
 
1338
      This value is only relevant if supports_merge_revisions is True.
1326
1339
 
1327
1340
    - supports_tags must be True if this log formatter supports tags.
1328
 
        Otherwise the tags attribute may not be populated.
 
1341
      Otherwise the tags attribute may not be populated.
1329
1342
 
1330
1343
    - supports_diff must be True if this log formatter supports diffs.
1331
 
        Otherwise the diff attribute may not be populated.
 
1344
      Otherwise the diff attribute may not be populated.
 
1345
 
 
1346
    - supports_signatures must be True if this log formatter supports GPG
 
1347
      signatures.
1332
1348
 
1333
1349
    Plugins can register functions to show custom revision properties using
1334
1350
    the properties_handler_registry. The registered function
1335
 
    must respect the following interface description:
 
1351
    must respect the following interface description::
 
1352
 
1336
1353
        def my_show_properties(properties_dict):
1337
1354
            # code that returns a dict {'name':'value'} of the properties
1338
1355
            # to be shown
1341
1358
 
1342
1359
    def __init__(self, to_file, show_ids=False, show_timezone='original',
1343
1360
                 delta_format=None, levels=None, show_advice=False,
1344
 
                 to_exact_file=None):
 
1361
                 to_exact_file=None, author_list_handler=None):
1345
1362
        """Create a LogFormatter.
1346
1363
 
1347
1364
        :param to_file: the file to output to
1348
 
        :param to_exact_file: if set, gives an output stream to which 
 
1365
        :param to_exact_file: if set, gives an output stream to which
1349
1366
             non-Unicode diffs are written.
1350
1367
        :param show_ids: if True, revision-ids are to be displayed
1351
1368
        :param show_timezone: the timezone to use
1355
1372
          let the log formatter decide.
1356
1373
        :param show_advice: whether to show advice at the end of the
1357
1374
          log or not
 
1375
        :param author_list_handler: callable generating a list of
 
1376
          authors to display for a given revision
1358
1377
        """
1359
1378
        self.to_file = to_file
1360
1379
        # 'exact' stream used to show diff, it should print content 'as is'
1375
1394
        self.levels = levels
1376
1395
        self._show_advice = show_advice
1377
1396
        self._merge_count = 0
 
1397
        self._author_list_handler = author_list_handler
1378
1398
 
1379
1399
    def get_levels(self):
1380
1400
        """Get the number of levels to display or 0 for all."""
1399
1419
            if advice_sep:
1400
1420
                self.to_file.write(advice_sep)
1401
1421
            self.to_file.write(
1402
 
                "Use --include-merges or -n0 to see merged revisions.\n")
 
1422
                "Use --include-merged or -n0 to see merged revisions.\n")
1403
1423
 
1404
1424
    def get_advice_separator(self):
1405
1425
        """Get the text separating the log from the closing advice."""
1412
1432
        return address
1413
1433
 
1414
1434
    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
 
1435
        return self.authors(rev, 'first', short=True, sep=', ')
 
1436
 
 
1437
    def authors(self, rev, who, short=False, sep=None):
 
1438
        """Generate list of authors, taking --authors option into account.
 
1439
 
 
1440
        The caller has to specify the name of a author list handler,
 
1441
        as provided by the author list registry, using the ``who``
 
1442
        argument.  That name only sets a default, though: when the
 
1443
        user selected a different author list generation using the
 
1444
        ``--authors`` command line switch, as represented by the
 
1445
        ``author_list_handler`` constructor argument, that value takes
 
1446
        precedence.
 
1447
 
 
1448
        :param rev: The revision for which to generate the list of authors.
 
1449
        :param who: Name of the default handler.
 
1450
        :param short: Whether to shorten names to either name or address.
 
1451
        :param sep: What separator to use for automatic concatenation.
 
1452
        """
 
1453
        if self._author_list_handler is not None:
 
1454
            # The user did specify --authors, which overrides the default
 
1455
            author_list_handler = self._author_list_handler
 
1456
        else:
 
1457
            # The user didn't specify --authors, so we use the caller's default
 
1458
            author_list_handler = author_list_registry.get(who)
 
1459
        names = author_list_handler(rev)
 
1460
        if short:
 
1461
            for i in range(len(names)):
 
1462
                name, address = config.parse_username(names[i])
 
1463
                if name:
 
1464
                    names[i] = name
 
1465
                else:
 
1466
                    names[i] = address
 
1467
        if sep is not None:
 
1468
            names = sep.join(names)
 
1469
        return names
1419
1470
 
1420
1471
    def merge_marker(self, revision):
1421
1472
        """Get the merge marker to include in the output or '' if none."""
1491
1542
    supports_delta = True
1492
1543
    supports_tags = True
1493
1544
    supports_diff = True
 
1545
    supports_signatures = True
1494
1546
 
1495
1547
    def __init__(self, *args, **kwargs):
1496
1548
        super(LongLogFormatter, self).__init__(*args, **kwargs)
1516
1568
                self.merge_marker(revision)))
1517
1569
        if revision.tags:
1518
1570
            lines.append('tags: %s' % (', '.join(revision.tags)))
1519
 
        if self.show_ids:
 
1571
        if self.show_ids or revision.revno is None:
1520
1572
            lines.append('revision-id: %s' % (revision.rev.revision_id,))
 
1573
        if self.show_ids:
1521
1574
            for parent_id in revision.rev.parent_ids:
1522
1575
                lines.append('parent: %s' % (parent_id,))
1523
1576
        lines.extend(self.custom_properties(revision.rev))
1524
1577
 
1525
1578
        committer = revision.rev.committer
1526
 
        authors = revision.rev.get_apparent_authors()
 
1579
        authors = self.authors(revision.rev, 'all')
1527
1580
        if authors != [committer]:
1528
1581
            lines.append('author: %s' % (", ".join(authors),))
1529
1582
        lines.append('committer: %s' % (committer,))
1534
1587
 
1535
1588
        lines.append('timestamp: %s' % (self.date_string(revision.rev),))
1536
1589
 
 
1590
        if revision.signature is not None:
 
1591
            lines.append('signature: ' + revision.signature)
 
1592
 
1537
1593
        lines.append('message:')
1538
1594
        if not revision.rev.message:
1539
1595
            lines.append('  (no message)')
1547
1603
        to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1548
1604
        if revision.delta is not None:
1549
1605
            # 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, 
 
1606
            from breezy.delta import report_delta
 
1607
            report_delta(to_file, revision.delta, short_status=False,
1552
1608
                         show_ids=self.show_ids, indent=indent)
1553
1609
        if revision.diff is not None:
1554
1610
            to_file.write(indent + 'diff:\n')
1586
1642
        indent = '    ' * depth
1587
1643
        revno_width = self.revno_width_by_depth.get(depth)
1588
1644
        if revno_width is None:
1589
 
            if revision.revno.find('.') == -1:
 
1645
            if revision.revno is None or revision.revno.find('.') == -1:
1590
1646
                # mainline revno, e.g. 12345
1591
1647
                revno_width = 5
1592
1648
            else:
1600
1656
        if revision.tags:
1601
1657
            tags = ' {%s}' % (', '.join(revision.tags))
1602
1658
        to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1603
 
                revision.revno, self.short_author(revision.rev),
 
1659
                revision.revno or "", self.short_author(revision.rev),
1604
1660
                format_date(revision.rev.timestamp,
1605
1661
                            revision.rev.timezone or 0,
1606
1662
                            self.show_timezone, date_fmt="%Y-%m-%d",
1607
1663
                            show_offset=False),
1608
1664
                tags, self.merge_marker(revision)))
1609
1665
        self.show_properties(revision.rev, indent+offset)
1610
 
        if self.show_ids:
 
1666
        if self.show_ids or revision.revno is None:
1611
1667
            to_file.write(indent + offset + 'revision-id:%s\n'
1612
1668
                          % (revision.rev.revision_id,))
1613
1669
        if not revision.rev.message:
1619
1675
 
1620
1676
        if revision.delta is not None:
1621
1677
            # 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, 
 
1678
            from breezy.delta import report_delta
 
1679
            report_delta(to_file, revision.delta,
 
1680
                         short_status=self.delta_format==1,
1625
1681
                         show_ids=self.show_ids, indent=indent + offset)
1626
1682
        if revision.diff is not None:
1627
1683
            self.show_diff(self.to_exact_file, revision.diff, '      ')
1666
1722
 
1667
1723
    def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1668
1724
        """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
 
1725
 
 
1726
        :param revno:      revision number or None.
 
1727
                           Revision numbers counts from 1.
 
1728
        :param rev:        revision object
 
1729
        :param max_chars:  maximum length of resulting string
 
1730
        :param tags:       list of tags or None
 
1731
        :param prefix:     string to prefix each line
 
1732
        :return:           formatted truncated string
1676
1733
        """
1677
1734
        out = []
1678
1735
        if revno:
1679
1736
            # show revno only when is not None
1680
1737
            out.append("%s:" % revno)
1681
 
        out.append(self.truncate(self.short_author(rev), 20))
 
1738
        if max_chars is not None:
 
1739
            out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
 
1740
        else:
 
1741
            out.append(self.short_author(rev))
1682
1742
        out.append(self.date_string(rev))
1683
1743
        if len(rev.parent_ids) > 1:
1684
1744
            out.append('[merge]')
1703
1763
                               self.show_timezone,
1704
1764
                               date_fmt='%Y-%m-%d',
1705
1765
                               show_offset=False)
1706
 
        committer_str = revision.rev.get_apparent_authors()[0].replace (' <', '  <')
1707
 
        to_file.write('%s  %s\n\n' % (date_str,committer_str))
 
1766
        committer_str = self.authors(revision.rev, 'first', sep=', ')
 
1767
        committer_str = committer_str.replace(' <', '  <')
 
1768
        to_file.write('%s  %s\n\n' % (date_str, committer_str))
1708
1769
 
1709
1770
        if revision.delta is not None and revision.delta.has_changed():
1710
1771
            for c in revision.delta.added + revision.delta.removed + revision.delta.modified:
1711
1772
                path, = c[:1]
1712
1773
                to_file.write('\t* %s:\n' % (path,))
1713
1774
            for c in revision.delta.renamed:
1714
 
                oldpath,newpath = c[:2]
 
1775
                oldpath, newpath = c[:2]
1715
1776
                # For renamed files, show both the old and the new path
1716
 
                to_file.write('\t* %s:\n\t* %s:\n' % (oldpath,newpath))
 
1777
                to_file.write('\t* %s:\n\t* %s:\n' % (oldpath, newpath))
1717
1778
            to_file.write('\n')
1718
1779
 
1719
1780
        if not revision.rev.message:
1742
1803
        return self.get(name)(*args, **kwargs)
1743
1804
 
1744
1805
    def get_default(self, branch):
1745
 
        return self.get(branch.get_config().log_format())
 
1806
        c = branch.get_config_stack()
 
1807
        return self.get(c.get('log_format'))
1746
1808
 
1747
1809
 
1748
1810
log_formatter_registry = LogFormatterRegistry()
1749
1811
 
1750
1812
 
1751
1813
log_formatter_registry.register('short', ShortLogFormatter,
1752
 
                                'Moderately short log format')
 
1814
                                'Moderately short log format.')
1753
1815
log_formatter_registry.register('long', LongLogFormatter,
1754
 
                                'Detailed log format')
 
1816
                                'Detailed log format.')
1755
1817
log_formatter_registry.register('line', LineLogFormatter,
1756
 
                                'Log format with one line per revision')
 
1818
                                'Log format with one line per revision.')
1757
1819
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1758
 
                                'Format used by GNU ChangeLog files')
 
1820
                                'Format used by GNU ChangeLog files.')
1759
1821
 
1760
1822
 
1761
1823
def register_formatter(name, formatter):
1771
1833
    try:
1772
1834
        return log_formatter_registry.make_formatter(name, *args, **kwargs)
1773
1835
    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)
 
1836
        raise errors.BzrCommandError(gettext("unknown log formatter: %r") % name)
 
1837
 
 
1838
 
 
1839
def author_list_all(rev):
 
1840
    return rev.get_apparent_authors()[:]
 
1841
 
 
1842
 
 
1843
def author_list_first(rev):
 
1844
    lst = rev.get_apparent_authors()
 
1845
    try:
 
1846
        return [lst[0]]
 
1847
    except IndexError:
 
1848
        return []
 
1849
 
 
1850
 
 
1851
def author_list_committer(rev):
 
1852
    return [rev.committer]
 
1853
 
 
1854
 
 
1855
author_list_registry = registry.Registry()
 
1856
 
 
1857
author_list_registry.register('all', author_list_all,
 
1858
                              'All authors')
 
1859
 
 
1860
author_list_registry.register('first', author_list_first,
 
1861
                              'The first author')
 
1862
 
 
1863
author_list_registry.register('committer', author_list_committer,
 
1864
                              'The committer')
1781
1865
 
1782
1866
 
1783
1867
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1800
1884
    # This is the first index which is different between
1801
1885
    # old and new
1802
1886
    base_idx = None
1803
 
    for i in xrange(max(len(new_rh),
1804
 
                        len(old_rh))):
 
1887
    for i in range(max(len(new_rh), len(old_rh))):
1805
1888
        if (len(new_rh) <= i
1806
1889
            or len(old_rh) <= i
1807
1890
            or new_rh[i] != old_rh[i]):
1848
1931
    old_revisions = set()
1849
1932
    new_history = []
1850
1933
    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)
 
1934
    graph = repository.get_graph()
 
1935
    new_iter = graph.iter_lefthand_ancestry(new_revision_id)
 
1936
    old_iter = graph.iter_lefthand_ancestry(old_revision_id)
1853
1937
    stop_revision = None
1854
1938
    do_old = True
1855
1939
    do_new = True
1856
1940
    while do_new or do_old:
1857
1941
        if do_new:
1858
1942
            try:
1859
 
                new_revision = new_iter.next()
 
1943
                new_revision = next(new_iter)
1860
1944
            except StopIteration:
1861
1945
                do_new = False
1862
1946
            else:
1867
1951
                    break
1868
1952
        if do_old:
1869
1953
            try:
1870
 
                old_revision = old_iter.next()
 
1954
                old_revision = next(old_iter)
1871
1955
            except StopIteration:
1872
1956
                do_old = False
1873
1957
            else:
1930
2014
        lf.log_revision(lr)
1931
2015
 
1932
2016
 
1933
 
def _get_info_for_log_files(revisionspec_list, file_list):
 
2017
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
1934
2018
    """Find file-ids and kinds given a list of files and a revision range.
1935
2019
 
1936
2020
    We search for files at the end of the range. If not found there,
1940
2024
    :param file_list: the list of paths given on the command line;
1941
2025
      the first of these can be a branch location or a file path,
1942
2026
      the remainder must be file paths
 
2027
    :param add_cleanup: When the branch returned is read locked,
 
2028
      an unlock call will be queued to the cleanup.
1943
2029
    :return: (branch, info_list, start_rev_info, end_rev_info) where
1944
2030
      info_list is a list of (relative_path, file_id, kind) tuples where
1945
2031
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1946
2032
      branch will be read-locked.
1947
2033
    """
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()
 
2034
    from breezy.builtins import _get_revision_range
 
2035
    tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
 
2036
        file_list[0])
 
2037
    add_cleanup(b.lock_read().unlock)
1951
2038
    # XXX: It's damn messy converting a list of paths to relative paths when
1952
2039
    # those paths might be deleted ones, they might be on a case-insensitive
1953
2040
    # filesystem and/or they might be in silly locations (like another branch).
1957
2044
    # case of running log in a nested directory, assuming paths beyond the
1958
2045
    # first one haven't been deleted ...
1959
2046
    if tree:
1960
 
        relpaths = [path] + safe_relpath_files(tree, file_list[1:])
 
2047
        relpaths = [path] + tree.safe_relpath_files(file_list[1:])
1961
2048
    else:
1962
2049
        relpaths = [path] + file_list[1:]
1963
2050
    info_list = []
1971
2058
        tree1 = None
1972
2059
        for fp in relpaths:
1973
2060
            file_id = tree.path2id(fp)
1974
 
            kind = _get_kind_for_file_id(tree, file_id)
 
2061
            kind = _get_kind_for_file_id(tree, fp, file_id)
1975
2062
            if file_id is None:
1976
2063
                # go back to when time began
1977
2064
                if tree1 is None:
1985
2072
                        tree1 = b.repository.revision_tree(rev1)
1986
2073
                if tree1:
1987
2074
                    file_id = tree1.path2id(fp)
1988
 
                    kind = _get_kind_for_file_id(tree1, file_id)
 
2075
                    kind = _get_kind_for_file_id(tree1, fp, file_id)
1989
2076
            info_list.append((fp, file_id, kind))
1990
2077
 
1991
2078
    elif start_rev_info == end_rev_info:
1993
2080
        tree = b.repository.revision_tree(end_rev_info.rev_id)
1994
2081
        for fp in relpaths:
1995
2082
            file_id = tree.path2id(fp)
1996
 
            kind = _get_kind_for_file_id(tree, file_id)
 
2083
            kind = _get_kind_for_file_id(tree, fp, file_id)
1997
2084
            info_list.append((fp, file_id, kind))
1998
2085
 
1999
2086
    else:
2007
2094
        tree1 = None
2008
2095
        for fp in relpaths:
2009
2096
            file_id = tree.path2id(fp)
2010
 
            kind = _get_kind_for_file_id(tree, file_id)
 
2097
            kind = _get_kind_for_file_id(tree, fp, file_id)
2011
2098
            if file_id is None:
2012
2099
                if tree1 is None:
2013
2100
                    rev_id = start_rev_info.rev_id
2017
2104
                    else:
2018
2105
                        tree1 = b.repository.revision_tree(rev_id)
2019
2106
                file_id = tree1.path2id(fp)
2020
 
                kind = _get_kind_for_file_id(tree1, file_id)
 
2107
                kind = _get_kind_for_file_id(tree1, fp, file_id)
2021
2108
            info_list.append((fp, file_id, kind))
2022
2109
    return b, info_list, start_rev_info, end_rev_info
2023
2110
 
2024
2111
 
2025
 
def _get_kind_for_file_id(tree, file_id):
 
2112
def _get_kind_for_file_id(tree, path, file_id):
2026
2113
    """Return the kind of a file-id or None if it doesn't exist."""
2027
2114
    if file_id is not None:
2028
 
        return tree.kind(file_id)
 
2115
        return tree.kind(path, file_id)
2029
2116
    else:
2030
2117
        return None
2031
2118
 
2034
2121
 
2035
2122
# Use the properties handlers to print out bug information if available
2036
2123
def _bugs_properties_handler(revision):
2037
 
    if revision.properties.has_key('bugs'):
 
2124
    if 'bugs' in revision.properties:
2038
2125
        bug_lines = revision.properties['bugs'].split('\n')
2039
2126
        bug_rows = [line.split(' ', 1) for line in bug_lines]
2040
2127
        fixed_bug_urls = [row[0] for row in bug_rows if
2041
2128
                          len(row) > 1 and row[1] == 'fixed']
2042
2129
 
2043
2130
        if fixed_bug_urls:
2044
 
            return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
 
2131
            return {ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls)):\
 
2132
                    ' '.join(fixed_bug_urls)}
2045
2133
    return {}
2046
2134
 
2047
2135
properties_handler_registry.register('bugs_properties_handler',