/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-20 23:20:37 UTC
  • mto: (6973.5.1 python3-c)
  • mto: This revision was merged to the branch mainline in revision 6984.
  • Revision ID: jelmer@jelmer.uk-20180520232037-inu6kdob1k6gwsyd
Fix a bunch of tests.

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:
206
198
    else:
207
199
        diff_type = None
208
200
 
 
201
    if isinstance(start_revision, int):
 
202
        try:
 
203
            start_revision = revisionspec.RevisionInfo(branch, start_revision)
 
204
        except errors.NoSuchRevision:
 
205
            raise errors.InvalidRevisionNumber(start_revision)
 
206
 
 
207
    if isinstance(end_revision, int):
 
208
        try:
 
209
            end_revision = revisionspec.RevisionInfo(branch, end_revision)
 
210
        except errors.NoSuchRevision:
 
211
            raise errors.InvalidRevisionNumber(end_revision)
 
212
 
 
213
    if end_revision is not None and end_revision.revno == 0:
 
214
        raise errors.InvalidRevisionNumber(end_revision.revno)
 
215
 
209
216
    # Build the request and execute it
210
217
    rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
211
218
        start_revision=start_revision, end_revision=end_revision,
214
221
    Logger(branch, rqst).show(lf)
215
222
 
216
223
 
217
 
# Note: This needs to be kept this in sync with the defaults in
 
224
# Note: This needs to be kept in sync with the defaults in
218
225
# make_log_request_dict() below
219
226
_DEFAULT_REQUEST_PARAMS = {
220
227
    'direction': 'reverse',
221
 
    'levels': 1,
 
228
    'levels': None,
222
229
    'generate_tags': True,
223
230
    'exclude_common_ancestry': False,
224
231
    '_match_using_deltas': True,
227
234
 
228
235
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
236
                          start_revision=None, end_revision=None, limit=None,
230
 
                          message_search=None, levels=1, generate_tags=True,
 
237
                          message_search=None, levels=None, generate_tags=True,
231
238
                          delta_type=None,
232
239
                          diff_type=None, _match_using_deltas=True,
233
 
                          exclude_common_ancestry=False,
 
240
                          exclude_common_ancestry=False, match=None,
 
241
                          signature=False, omit_merges=False,
234
242
                          ):
235
243
    """Convenience function for making a logging request dictionary.
236
244
 
257
265
      matching commit messages
258
266
 
259
267
    :param levels: the number of levels of revisions to
260
 
      generate; 1 for just the mainline; 0 for all levels.
 
268
      generate; 1 for just the mainline; 0 for all levels, or None for
 
269
      a sensible default.
261
270
 
262
271
    :param generate_tags: If True, include tags for matched revisions.
263
 
 
 
272
`
264
273
    :param delta_type: Either 'full', 'partial' or None.
265
274
      'full' means generate the complete delta - adds/deletes/modifies/etc;
266
275
      'partial' means filter the delta using specific_fileids;
273
282
 
274
283
    :param _match_using_deltas: a private parameter controlling the
275
284
      algorithm used for matching specific_fileids. This parameter
276
 
      may be removed in the future so bzrlib client code should NOT
 
285
      may be removed in the future so breezy client code should NOT
277
286
      use it.
278
287
 
279
288
    :param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
289
      range operator or as a graph difference.
 
290
 
 
291
    :param signature: show digital signature information
 
292
 
 
293
    :param match: Dictionary of list of search strings to use when filtering
 
294
      revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
 
295
      the empty string to match any of the preceding properties.
 
296
 
 
297
    :param omit_merges: If True, commits with more than one parent are
 
298
      omitted.
 
299
 
281
300
    """
 
301
    # Take care of old style message_search parameter
 
302
    if message_search:
 
303
        if match:
 
304
            if 'message' in match:
 
305
                match['message'].append(message_search)
 
306
            else:
 
307
                match['message'] = [message_search]
 
308
        else:
 
309
            match={ 'message': [message_search] }
282
310
    return {
283
311
        'direction': direction,
284
312
        'specific_fileids': specific_fileids,
285
313
        'start_revision': start_revision,
286
314
        'end_revision': end_revision,
287
315
        'limit': limit,
288
 
        'message_search': message_search,
289
316
        'levels': levels,
290
317
        'generate_tags': generate_tags,
291
318
        'delta_type': delta_type,
292
319
        'diff_type': diff_type,
293
320
        'exclude_common_ancestry': exclude_common_ancestry,
 
321
        'signature': signature,
 
322
        'match': match,
 
323
        'omit_merges': omit_merges,
294
324
        # Add 'private' attributes for features that may be deprecated
295
325
        '_match_using_deltas': _match_using_deltas,
296
326
    }
298
328
 
299
329
def _apply_log_request_defaults(rqst):
300
330
    """Apply default values to a request dictionary."""
301
 
    result = _DEFAULT_REQUEST_PARAMS
 
331
    result = _DEFAULT_REQUEST_PARAMS.copy()
302
332
    if rqst:
303
333
        result.update(rqst)
304
334
    return result
305
335
 
306
336
 
 
337
def format_signature_validity(rev_id, branch):
 
338
    """get the signature validity
 
339
 
 
340
    :param rev_id: revision id to validate
 
341
    :param branch: branch of revision
 
342
    :return: human readable string to print to log
 
343
    """
 
344
    from breezy import gpg
 
345
 
 
346
    gpg_strategy = gpg.GPGStrategy(branch.get_config_stack())
 
347
    result = branch.repository.verify_revision_signature(rev_id, gpg_strategy)
 
348
    if result[0] == gpg.SIGNATURE_VALID:
 
349
        return u"valid signature from {0}".format(result[1])
 
350
    if result[0] == gpg.SIGNATURE_KEY_MISSING:
 
351
        return "unknown key {0}".format(result[1])
 
352
    if result[0] == gpg.SIGNATURE_NOT_VALID:
 
353
        return "invalid signature!"
 
354
    if result[0] == gpg.SIGNATURE_NOT_SIGNED:
 
355
        return "no signature"
 
356
 
 
357
 
307
358
class LogGenerator(object):
308
359
    """A generator of log revisions."""
309
360
 
354
405
        # Tweak the LogRequest based on what the LogFormatter can handle.
355
406
        # (There's no point generating stuff if the formatter can't display it.)
356
407
        rqst = self.rqst
357
 
        rqst['levels'] = lf.get_levels()
 
408
        if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
 
409
            # user didn't specify levels, use whatever the LF can handle:
 
410
            rqst['levels'] = lf.get_levels()
 
411
 
358
412
        if not getattr(lf, 'supports_tags', False):
359
413
            rqst['generate_tags'] = False
360
414
        if not getattr(lf, 'supports_delta', False):
361
415
            rqst['delta_type'] = None
362
416
        if not getattr(lf, 'supports_diff', False):
363
417
            rqst['diff_type'] = None
 
418
        if not getattr(lf, 'supports_signatures', False):
 
419
            rqst['signature'] = False
364
420
 
365
421
        # Find and print the interesting revisions
366
422
        generator = self._generator_factory(self.branch, rqst)
367
 
        for lr in generator.iter_log_revisions():
368
 
            lf.log_revision(lr)
 
423
        try:
 
424
            for lr in generator.iter_log_revisions():
 
425
                lf.log_revision(lr)
 
426
        except errors.GhostRevisionUnusableHere:
 
427
            raise errors.BzrCommandError(
 
428
                    gettext('Further revision history missing.'))
369
429
        lf.show_advice()
370
430
 
371
431
    def _generator_factory(self, branch, rqst):
372
432
        """Make the LogGenerator object to use.
373
 
        
 
433
 
374
434
        Subclasses may wish to override this.
375
435
        """
376
436
        return _DefaultLogGenerator(branch, rqst)
400
460
        levels = rqst.get('levels')
401
461
        limit = rqst.get('limit')
402
462
        diff_type = rqst.get('diff_type')
 
463
        show_signature = rqst.get('signature')
 
464
        omit_merges = rqst.get('omit_merges')
403
465
        log_count = 0
404
466
        revision_iterator = self._create_log_revision_iterator()
405
467
        for revs in revision_iterator:
407
469
                # 0 levels means show everything; merge_depth counts from 0
408
470
                if levels != 0 and merge_depth >= levels:
409
471
                    continue
 
472
                if omit_merges and len(rev.parent_ids) > 1:
 
473
                    continue
 
474
                if rev is None:
 
475
                    raise errors.GhostRevisionUnusableHere(rev_id)
410
476
                if diff_type is None:
411
477
                    diff = None
412
478
                else:
413
479
                    diff = self._format_diff(rev, rev_id, diff_type)
 
480
                if show_signature:
 
481
                    signature = format_signature_validity(rev_id, self.branch)
 
482
                else:
 
483
                    signature = None
414
484
                yield LogRevision(rev, revno, merge_depth, delta,
415
 
                    self.rev_tag_dict.get(rev_id), diff)
 
485
                    self.rev_tag_dict.get(rev_id), diff, signature)
416
486
                if limit:
417
487
                    log_count += 1
418
488
                    if log_count >= limit:
431
501
            specific_files = [tree_2.id2path(id) for id in file_ids]
432
502
        else:
433
503
            specific_files = None
434
 
        s = StringIO()
 
504
        s = BytesIO()
 
505
        path_encoding = get_diff_header_encoding()
435
506
        diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
436
 
            new_label='')
 
507
            new_label='', path_encoding=path_encoding)
437
508
        return s.getvalue()
438
509
 
439
510
    def _create_log_revision_iterator(self):
472
543
 
473
544
        # Apply the other filters
474
545
        return make_log_rev_iterator(self.branch, view_revisions,
475
 
            rqst.get('delta_type'), rqst.get('message_search'),
 
546
            rqst.get('delta_type'), rqst.get('match'),
476
547
            file_ids=rqst.get('specific_fileids'),
477
548
            direction=rqst.get('direction'))
478
549
 
491
562
            rqst.get('specific_fileids')[0], view_revisions,
492
563
            include_merges=rqst.get('levels') != 1)
493
564
        return make_log_rev_iterator(self.branch, view_revisions,
494
 
            rqst.get('delta_type'), rqst.get('message_search'))
 
565
            rqst.get('delta_type'), rqst.get('match'))
495
566
 
496
567
 
497
568
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
576
             a list of the same tuples.
506
577
    """
507
578
    if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
 
        raise errors.BzrCommandError(
509
 
            '--exclude-common-ancestry requires two different revisions')
 
579
        raise errors.BzrCommandError(gettext(
 
580
            '--exclude-common-ancestry requires two different revisions'))
510
581
    if direction not in ('reverse', 'forward'):
511
 
        raise ValueError('invalid direction %r' % direction)
512
 
    br_revno, br_rev_id = branch.last_revision_info()
513
 
    if br_revno == 0:
 
582
        raise ValueError(gettext('invalid direction %r') % direction)
 
583
    br_rev_id = branch.last_revision()
 
584
    if br_rev_id == _mod_revision.NULL_REVISION:
514
585
        return []
515
586
 
516
587
    if (end_rev_id and start_rev_id == end_rev_id
517
588
        and (not generate_merge_revisions
518
589
             or not _has_merges(branch, end_rev_id))):
519
590
        # 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)))
 
591
        return  _generate_one_revision(branch, end_rev_id, br_rev_id,
 
592
                                       branch.revno())
 
593
    if not generate_merge_revisions:
 
594
        try:
 
595
            # If we only want to see linear revisions, we can iterate ...
 
596
            iter_revs = _linear_view_revisions(
 
597
                branch, start_rev_id, end_rev_id,
 
598
                exclude_common_ancestry=exclude_common_ancestry)
 
599
            # If a start limit was given and it's not obviously an
 
600
            # ancestor of the end limit, check it before outputting anything
 
601
            if (direction == 'forward'
 
602
                or (start_rev_id and not _is_obvious_ancestor(
 
603
                        branch, start_rev_id, end_rev_id))):
 
604
                    iter_revs = list(iter_revs)
 
605
            if direction == 'forward':
 
606
                iter_revs = reversed(iter_revs)
 
607
            return iter_revs
 
608
        except _StartNotLinearAncestor:
 
609
            # Switch to the slower implementation that may be able to find a
 
610
            # non-obvious ancestor out of the left-hand history.
 
611
            pass
 
612
    iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
 
613
                                        direction, delayed_graph_generation,
 
614
                                        exclude_common_ancestry)
 
615
    if direction == 'forward':
 
616
        iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
534
617
    return iter_revs
535
618
 
536
619
 
539
622
        # It's the tip
540
623
        return [(br_rev_id, br_revno, 0)]
541
624
    else:
542
 
        revno = branch.revision_id_to_dotted_revno(rev_id)
543
 
        revno_str = '.'.join(str(n) for n in revno)
 
625
        revno_str = _compute_revno_str(branch, rev_id)
544
626
        return [(rev_id, revno_str, 0)]
545
627
 
546
628
 
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
629
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
630
                            delayed_graph_generation,
563
631
                            exclude_common_ancestry=False):
572
640
    if delayed_graph_generation:
573
641
        try:
574
642
            for rev_id, revno, depth in  _linear_view_revisions(
575
 
                branch, start_rev_id, end_rev_id):
 
643
                branch, start_rev_id, end_rev_id, exclude_common_ancestry):
576
644
                if _has_merges(branch, rev_id):
577
645
                    # The end_rev_id can be nested down somewhere. We need an
578
646
                    # explicit ancestry check. There is an ambiguity here as we
599
667
        except _StartNotLinearAncestor:
600
668
            # A merge was never detected so the lower revision limit can't
601
669
            # be nested down somewhere
602
 
            raise errors.BzrCommandError('Start revision not found in'
603
 
                ' history of end revision.')
 
670
            raise errors.BzrCommandError(gettext('Start revision not found in'
 
671
                ' history of end revision.'))
604
672
 
605
673
    # We exit the loop above because we encounter a revision with merges, from
606
674
    # this revision, we need to switch to _graph_view_revisions.
610
678
    # shown naturally, i.e. just like it is for linear logging. We can easily
611
679
    # make forward the exact opposite display, but showing the merge revisions
612
680
    # indented at the end seems slightly nicer in that case.
613
 
    view_revisions = chain(iter(initial_revisions),
 
681
    view_revisions = itertools.chain(iter(initial_revisions),
614
682
        _graph_view_revisions(branch, start_rev_id, end_rev_id,
615
683
                              rebase_initial_depths=(direction == 'reverse'),
616
684
                              exclude_common_ancestry=exclude_common_ancestry))
623
691
    return len(parents) > 1
624
692
 
625
693
 
 
694
def _compute_revno_str(branch, rev_id):
 
695
    """Compute the revno string from a rev_id.
 
696
 
 
697
    :return: The revno string, or None if the revision is not in the supplied
 
698
        branch.
 
699
    """
 
700
    try:
 
701
        revno = branch.revision_id_to_dotted_revno(rev_id)
 
702
    except errors.NoSuchRevision:
 
703
        # The revision must be outside of this branch
 
704
        return None
 
705
    else:
 
706
        return '.'.join(str(n) for n in revno)
 
707
 
 
708
 
626
709
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
710
    """Is start_rev_id an obvious ancestor of end_rev_id?"""
628
711
    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)
 
712
        try:
 
713
            start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
 
714
            end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
 
715
        except errors.NoSuchRevision:
 
716
            # one or both is not in the branch; not obvious
 
717
            return False
631
718
        if len(start_dotted) == 1 and len(end_dotted) == 1:
632
719
            # both on mainline
633
720
            return start_dotted[0] <= end_dotted[0]
643
730
    return True
644
731
 
645
732
 
646
 
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
 
733
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
 
734
                           exclude_common_ancestry=False):
647
735
    """Calculate a sequence of revisions to view, newest to oldest.
648
736
 
649
737
    :param start_rev_id: the lower revision-id
650
738
    :param end_rev_id: the upper revision-id
 
739
    :param exclude_common_ancestry: Whether the start_rev_id should be part of
 
740
        the iterated revisions.
651
741
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
 
742
        dotted_revno will be None for ghosts
652
743
    :raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
 
      is not found walking the left-hand history
 
744
        is not found walking the left-hand history
654
745
    """
655
 
    br_revno, br_rev_id = branch.last_revision_info()
656
746
    repo = branch.repository
 
747
    graph = repo.get_graph()
657
748
    if start_rev_id is None and end_rev_id is None:
658
 
        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
 
749
        try:
 
750
            br_revno, br_rev_id = branch.last_revision_info()
 
751
        except errors.GhostRevisionsHaveNoRevno:
 
752
            br_rev_id = branch.last_revision()
 
753
            cur_revno = None
 
754
        else:
 
755
            cur_revno = br_revno
 
756
        graph_iter = graph.iter_lefthand_ancestry(br_rev_id,
 
757
            (_mod_revision.NULL_REVISION,))
 
758
        while True:
 
759
            try:
 
760
                revision_id = next(graph_iter)
 
761
            except errors.RevisionNotPresent as e:
 
762
                # Oops, a ghost.
 
763
                yield e.revision_id, None, None
 
764
                break
 
765
            else:
 
766
                yield revision_id, str(cur_revno) if cur_revno is not None else None, 0
 
767
                if cur_revno is not None:
 
768
                    cur_revno -= 1
662
769
    else:
 
770
        br_rev_id = branch.last_revision()
663
771
        if end_rev_id is None:
664
772
            end_rev_id = br_rev_id
665
773
        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
 
774
        graph_iter = graph.iter_lefthand_ancestry(end_rev_id,
 
775
            (_mod_revision.NULL_REVISION,))
 
776
        while True:
 
777
            try:
 
778
                revision_id = next(graph_iter)
 
779
            except StopIteration:
 
780
                break
 
781
            except errors.RevisionNotPresent as e:
 
782
                # Oops, a ghost.
 
783
                yield e.revision_id, None, None
672
784
                break
673
785
            else:
674
 
                yield revision_id, revno_str, 0
675
 
        else:
676
 
            if not found_start:
677
 
                raise _StartNotLinearAncestor()
 
786
                revno_str = _compute_revno_str(branch, revision_id)
 
787
                if not found_start and revision_id == start_rev_id:
 
788
                    if not exclude_common_ancestry:
 
789
                        yield revision_id, revno_str, 0
 
790
                    found_start = True
 
791
                    break
 
792
                else:
 
793
                    yield revision_id, revno_str, 0
 
794
        if not found_start:
 
795
            raise _StartNotLinearAncestor()
678
796
 
679
797
 
680
798
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
721
839
            yield rev_id, '.'.join(map(str, revno)), merge_depth
722
840
 
723
841
 
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
842
def _rebase_merge_depth(view_revisions):
744
843
    """Adjust depths upwards so the top level is 0."""
745
844
    # If either the first or last revision have a merge_depth of 0, we're done
746
845
    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])
 
846
        min_depth = min([d for r, n, d in view_revisions])
748
847
        if min_depth != 0:
749
 
            view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
 
848
            view_revisions = [(r, n, d-min_depth) for r, n, d in view_revisions]
750
849
    return view_revisions
751
850
 
752
851
 
767
866
    """
768
867
    # Convert view_revisions into (view, None, None) groups to fit with
769
868
    # the standard interface here.
770
 
    if type(view_revisions) == list:
 
869
    if isinstance(view_revisions, list):
771
870
        # A single batch conversion is faster than many incremental ones.
772
871
        # As we have all the data, do a batch conversion.
773
872
        nones = [None] * len(view_revisions)
774
 
        log_rev_iterator = iter([zip(view_revisions, nones, nones)])
 
873
        log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
775
874
    else:
776
875
        def _convert():
777
876
            for view in view_revisions:
789
888
    return log_rev_iterator
790
889
 
791
890
 
792
 
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
 
891
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
892
    """Create a filtered iterator of log_rev_iterator matching on a regex.
794
893
 
795
894
    :param branch: The branch being logged.
796
895
    :param generate_delta: Whether to generate a delta for each revision.
797
 
    :param search: A user text search string.
 
896
    :param match: A dictionary with properties as keys and lists of strings
 
897
        as values. To match, a revision may match any of the supplied strings
 
898
        within a single property but must match at least one string for each
 
899
        property.
798
900
    :param log_rev_iterator: An input iterator containing all revisions that
799
901
        could be displayed, in lists.
800
902
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
801
903
        delta).
802
904
    """
803
 
    if search is None:
 
905
    if not match:
804
906
        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):
 
907
    searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
 
908
                for k, v in match.items()]
 
909
    return _filter_re(searchRE, log_rev_iterator)
 
910
 
 
911
 
 
912
def _filter_re(searchRE, log_rev_iterator):
811
913
    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
 
 
 
914
        new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
 
915
        if new_revs:
 
916
            yield new_revs
 
917
 
 
918
def _match_filter(searchRE, rev):
 
919
    strings = {
 
920
               'message': (rev.message,),
 
921
               'committer': (rev.committer,),
 
922
               'author': (rev.get_apparent_authors()),
 
923
               'bugs': list(rev.iter_bugs())
 
924
               }
 
925
    strings[''] = [item for inner_list in strings.values()
 
926
                   for item in inner_list]
 
927
    for (k, v) in searchRE:
 
928
        if k in strings and not _match_any_filter(strings[k], v):
 
929
            return False
 
930
    return True
 
931
 
 
932
def _match_any_filter(strings, res):
 
933
    return any(re.search(s) for re in res for s in strings)
818
934
 
819
935
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
936
    fileids=None, direction='reverse'):
865
981
        new_revs = []
866
982
        if delta_type == 'full' and not check_fileids:
867
983
            deltas = repository.get_deltas_for_revisions(revisions)
868
 
            for rev, delta in izip(revs, deltas):
 
984
            for rev, delta in zip(revs, deltas):
869
985
                new_revs.append((rev[0], rev[1], delta))
870
986
        else:
871
987
            deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
872
 
            for rev, delta in izip(revs, deltas):
 
988
            for rev, delta in zip(revs, deltas):
873
989
                if check_fileids:
874
990
                    if delta is None or not delta.has_changed():
875
991
                        continue
893
1009
 
894
1010
def _update_fileids(delta, fileids, stop_on):
895
1011
    """Update the set of file-ids to search based on file lifecycle events.
896
 
    
 
1012
 
897
1013
    :param fileids: a set of fileids to update
898
1014
    :param stop_on: either 'add' or 'remove' - take file-ids out of the
899
1015
      fileids set once their add or remove entry is detected respectively
923
1039
    for revs in log_rev_iterator:
924
1040
        # r = revision_id, n = revno, d = merge depth
925
1041
        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
 
1042
        revisions = dict(repository.iter_revisions(revision_ids))
 
1043
        yield [(rev[0], revisions[rev[0][0]], rev[2]) for rev in revs]
930
1044
 
931
1045
 
932
1046
def _make_batch_filter(branch, generate_delta, search, log_rev_iterator):
940
1054
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
941
1055
        delta).
942
1056
    """
943
 
    repository = branch.repository
944
1057
    num = 9
945
1058
    for batch in log_rev_iterator:
946
1059
        batch = iter(batch)
958
1071
    :param  branch: The branch containing the revisions.
959
1072
 
960
1073
    :param  start_revision: The first revision to be logged.
961
 
            For backwards compatibility this may be a mainline integer revno,
962
1074
            but for merge revision support a RevisionInfo is expected.
963
1075
 
964
1076
    :param  end_revision: The last revision to be logged.
967
1079
 
968
1080
    :return: (start_rev_id, end_rev_id) tuple.
969
1081
    """
970
 
    branch_revno, branch_rev_id = branch.last_revision_info()
971
1082
    start_rev_id = None
972
 
    if start_revision is None:
 
1083
    start_revno = None
 
1084
    if start_revision is not None:
 
1085
        if not isinstance(start_revision, revisionspec.RevisionInfo):
 
1086
            raise TypeError(start_revision)
 
1087
        start_rev_id = start_revision.rev_id
 
1088
        start_revno = start_revision.revno
 
1089
    if start_revno is None:
973
1090
        start_revno = 1
974
 
    else:
975
 
        if isinstance(start_revision, revisionspec.RevisionInfo):
976
 
            start_rev_id = start_revision.rev_id
977
 
            start_revno = start_revision.revno or 1
978
 
        else:
979
 
            branch.check_real_revno(start_revision)
980
 
            start_revno = start_revision
981
 
            start_rev_id = branch.get_rev_id(start_revno)
982
1091
 
983
1092
    end_rev_id = None
984
 
    if end_revision is None:
985
 
        end_revno = branch_revno
986
 
    else:
987
 
        if isinstance(end_revision, revisionspec.RevisionInfo):
988
 
            end_rev_id = end_revision.rev_id
989
 
            end_revno = end_revision.revno or branch_revno
990
 
        else:
991
 
            branch.check_real_revno(end_revision)
992
 
            end_revno = end_revision
993
 
            end_rev_id = branch.get_rev_id(end_revno)
 
1093
    end_revno = None
 
1094
    if end_revision is not None:
 
1095
        if not isinstance(end_revision, revisionspec.RevisionInfo):
 
1096
            raise TypeError(start_revision)
 
1097
        end_rev_id = end_revision.rev_id
 
1098
        end_revno = end_revision.revno
 
1099
    if end_revno is None:
 
1100
        try:
 
1101
            end_revno = branch.revno()
 
1102
        except errors.GhostRevisionsHaveNoRevno:
 
1103
            end_revno = None
994
1104
 
995
 
    if branch_revno != 0:
 
1105
    if branch.last_revision() != _mod_revision.NULL_REVISION:
996
1106
        if (start_rev_id == _mod_revision.NULL_REVISION
997
1107
            or end_rev_id == _mod_revision.NULL_REVISION):
998
 
            raise errors.BzrCommandError('Logging revision 0 is invalid.')
999
 
        if start_revno > end_revno:
1000
 
            raise errors.BzrCommandError("Start revision must be older than "
1001
 
                                         "the end revision.")
 
1108
            raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
 
1109
        if end_revno is not None and start_revno > end_revno:
 
1110
            raise errors.BzrCommandError(gettext("Start revision must be "
 
1111
                                         "older than the end revision."))
1002
1112
    return (start_rev_id, end_rev_id)
1003
1113
 
1004
1114
 
1053
1163
 
1054
1164
    if ((start_rev_id == _mod_revision.NULL_REVISION)
1055
1165
        or (end_rev_id == _mod_revision.NULL_REVISION)):
1056
 
        raise errors.BzrCommandError('Logging revision 0 is invalid.')
 
1166
        raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1057
1167
    if start_revno > end_revno:
1058
 
        raise errors.BzrCommandError("Start revision must be older than "
1059
 
                                     "the end revision.")
 
1168
        raise errors.BzrCommandError(gettext("Start revision must be older "
 
1169
                                     "than the end revision."))
1060
1170
 
1061
1171
    if end_revno < start_revno:
1062
1172
        return None, None, None, None
1063
1173
    cur_revno = branch_revno
1064
1174
    rev_nos = {}
1065
1175
    mainline_revs = []
1066
 
    for revision_id in branch.repository.iter_reverse_revision_history(
1067
 
                        branch_last_revision):
 
1176
    graph = branch.repository.get_graph()
 
1177
    for revision_id in graph.iter_lefthand_ancestry(
 
1178
            branch_last_revision, (_mod_revision.NULL_REVISION,)):
1068
1179
        if cur_revno < start_revno:
1069
1180
            # We have gone far enough, but we always add 1 more revision
1070
1181
            rev_nos[revision_id] = cur_revno
1084
1195
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
1085
1196
 
1086
1197
 
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
1198
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
1199
    include_merges=True):
1133
1200
    r"""Return the list of revision ids which touch a given file id.
1136
1203
    This includes the revisions which directly change the file id,
1137
1204
    and the revisions which merge these changes. So if the
1138
1205
    revision graph is::
 
1206
 
1139
1207
        A-.
1140
1208
        |\ \
1141
1209
        B C E
1168
1236
    """
1169
1237
    # Lookup all possible text keys to determine which ones actually modified
1170
1238
    # the file.
 
1239
    graph = branch.repository.get_file_graph()
 
1240
    get_parent_map = graph.get_parent_map
1171
1241
    text_keys = [(file_id, rev_id) for rev_id, revno, depth in view_revisions]
1172
1242
    next_keys = None
1173
1243
    # Looking up keys in batches of 1000 can cut the time in half, as well as
1177
1247
    #       indexing layer. We might consider passing in hints as to the known
1178
1248
    #       access pattern (sparse/clustered, high success rate/low success
1179
1249
    #       rate). This particular access is clustered with a low success rate.
1180
 
    get_parent_map = branch.repository.texts.get_parent_map
1181
1250
    modified_text_revisions = set()
1182
1251
    chunk_size = 1000
1183
 
    for start in xrange(0, len(text_keys), chunk_size):
 
1252
    for start in range(0, len(text_keys), chunk_size):
1184
1253
        next_keys = text_keys[start:start + chunk_size]
1185
1254
        # Only keep the revision_id portion of the key
1186
1255
        modified_text_revisions.update(
1201
1270
 
1202
1271
        if rev_id in modified_text_revisions:
1203
1272
            # This needs to be logged, along with the extra revisions
1204
 
            for idx in xrange(len(current_merge_stack)):
 
1273
            for idx in range(len(current_merge_stack)):
1205
1274
                node = current_merge_stack[idx]
1206
1275
                if node is not None:
1207
1276
                    if include_merges or node[2] == 0:
1210
1279
    return result
1211
1280
 
1212
1281
 
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
1282
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1283
    """Reverse revisions by depth.
1256
1284
 
1291
1319
    """
1292
1320
 
1293
1321
    def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
1294
 
                 tags=None, diff=None):
 
1322
                 tags=None, diff=None, signature=None):
1295
1323
        self.rev = rev
1296
 
        self.revno = str(revno)
 
1324
        if revno is None:
 
1325
            self.revno = None
 
1326
        else:
 
1327
            self.revno = str(revno)
1297
1328
        self.merge_depth = merge_depth
1298
1329
        self.delta = delta
1299
1330
        self.tags = tags
1300
1331
        self.diff = diff
 
1332
        self.signature = signature
1301
1333
 
1302
1334
 
1303
1335
class LogFormatter(object):
1312
1344
    to indicate which LogRevision attributes it supports:
1313
1345
 
1314
1346
    - 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.
 
1347
      Otherwise the delta attribute may not be populated.  The 'delta_format'
 
1348
      attribute describes whether the 'short_status' format (1) or the long
 
1349
      one (2) should be used.
1318
1350
 
1319
1351
    - 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.
 
1352
      merge revisions.  If not, then only mainline revisions will be passed
 
1353
      to the formatter.
1322
1354
 
1323
1355
    - 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.
 
1356
      The default value is zero meaning display all levels.
 
1357
      This value is only relevant if supports_merge_revisions is True.
1326
1358
 
1327
1359
    - supports_tags must be True if this log formatter supports tags.
1328
 
        Otherwise the tags attribute may not be populated.
 
1360
      Otherwise the tags attribute may not be populated.
1329
1361
 
1330
1362
    - supports_diff must be True if this log formatter supports diffs.
1331
 
        Otherwise the diff attribute may not be populated.
 
1363
      Otherwise the diff attribute may not be populated.
 
1364
 
 
1365
    - supports_signatures must be True if this log formatter supports GPG
 
1366
      signatures.
1332
1367
 
1333
1368
    Plugins can register functions to show custom revision properties using
1334
1369
    the properties_handler_registry. The registered function
1335
 
    must respect the following interface description:
 
1370
    must respect the following interface description::
 
1371
 
1336
1372
        def my_show_properties(properties_dict):
1337
1373
            # code that returns a dict {'name':'value'} of the properties
1338
1374
            # to be shown
1341
1377
 
1342
1378
    def __init__(self, to_file, show_ids=False, show_timezone='original',
1343
1379
                 delta_format=None, levels=None, show_advice=False,
1344
 
                 to_exact_file=None):
 
1380
                 to_exact_file=None, author_list_handler=None):
1345
1381
        """Create a LogFormatter.
1346
1382
 
1347
1383
        :param to_file: the file to output to
1348
 
        :param to_exact_file: if set, gives an output stream to which 
 
1384
        :param to_exact_file: if set, gives an output stream to which
1349
1385
             non-Unicode diffs are written.
1350
1386
        :param show_ids: if True, revision-ids are to be displayed
1351
1387
        :param show_timezone: the timezone to use
1355
1391
          let the log formatter decide.
1356
1392
        :param show_advice: whether to show advice at the end of the
1357
1393
          log or not
 
1394
        :param author_list_handler: callable generating a list of
 
1395
          authors to display for a given revision
1358
1396
        """
1359
1397
        self.to_file = to_file
1360
1398
        # 'exact' stream used to show diff, it should print content 'as is'
1375
1413
        self.levels = levels
1376
1414
        self._show_advice = show_advice
1377
1415
        self._merge_count = 0
 
1416
        self._author_list_handler = author_list_handler
1378
1417
 
1379
1418
    def get_levels(self):
1380
1419
        """Get the number of levels to display or 0 for all."""
1399
1438
            if advice_sep:
1400
1439
                self.to_file.write(advice_sep)
1401
1440
            self.to_file.write(
1402
 
                "Use --include-merges or -n0 to see merged revisions.\n")
 
1441
                "Use --include-merged or -n0 to see merged revisions.\n")
1403
1442
 
1404
1443
    def get_advice_separator(self):
1405
1444
        """Get the text separating the log from the closing advice."""
1412
1451
        return address
1413
1452
 
1414
1453
    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
 
1454
        return self.authors(rev, 'first', short=True, sep=', ')
 
1455
 
 
1456
    def authors(self, rev, who, short=False, sep=None):
 
1457
        """Generate list of authors, taking --authors option into account.
 
1458
 
 
1459
        The caller has to specify the name of a author list handler,
 
1460
        as provided by the author list registry, using the ``who``
 
1461
        argument.  That name only sets a default, though: when the
 
1462
        user selected a different author list generation using the
 
1463
        ``--authors`` command line switch, as represented by the
 
1464
        ``author_list_handler`` constructor argument, that value takes
 
1465
        precedence.
 
1466
 
 
1467
        :param rev: The revision for which to generate the list of authors.
 
1468
        :param who: Name of the default handler.
 
1469
        :param short: Whether to shorten names to either name or address.
 
1470
        :param sep: What separator to use for automatic concatenation.
 
1471
        """
 
1472
        if self._author_list_handler is not None:
 
1473
            # The user did specify --authors, which overrides the default
 
1474
            author_list_handler = self._author_list_handler
 
1475
        else:
 
1476
            # The user didn't specify --authors, so we use the caller's default
 
1477
            author_list_handler = author_list_registry.get(who)
 
1478
        names = author_list_handler(rev)
 
1479
        if short:
 
1480
            for i in range(len(names)):
 
1481
                name, address = config.parse_username(names[i])
 
1482
                if name:
 
1483
                    names[i] = name
 
1484
                else:
 
1485
                    names[i] = address
 
1486
        if sep is not None:
 
1487
            names = sep.join(names)
 
1488
        return names
1419
1489
 
1420
1490
    def merge_marker(self, revision):
1421
1491
        """Get the merge marker to include in the output or '' if none."""
1491
1561
    supports_delta = True
1492
1562
    supports_tags = True
1493
1563
    supports_diff = True
 
1564
    supports_signatures = True
1494
1565
 
1495
1566
    def __init__(self, *args, **kwargs):
1496
1567
        super(LongLogFormatter, self).__init__(*args, **kwargs)
1516
1587
                self.merge_marker(revision)))
1517
1588
        if revision.tags:
1518
1589
            lines.append('tags: %s' % (', '.join(revision.tags)))
1519
 
        if self.show_ids:
 
1590
        if self.show_ids or revision.revno is None:
1520
1591
            lines.append('revision-id: %s' % (revision.rev.revision_id,))
 
1592
        if self.show_ids:
1521
1593
            for parent_id in revision.rev.parent_ids:
1522
1594
                lines.append('parent: %s' % (parent_id,))
1523
1595
        lines.extend(self.custom_properties(revision.rev))
1524
1596
 
1525
1597
        committer = revision.rev.committer
1526
 
        authors = revision.rev.get_apparent_authors()
 
1598
        authors = self.authors(revision.rev, 'all')
1527
1599
        if authors != [committer]:
1528
1600
            lines.append('author: %s' % (", ".join(authors),))
1529
1601
        lines.append('committer: %s' % (committer,))
1534
1606
 
1535
1607
        lines.append('timestamp: %s' % (self.date_string(revision.rev),))
1536
1608
 
 
1609
        if revision.signature is not None:
 
1610
            lines.append('signature: ' + revision.signature)
 
1611
 
1537
1612
        lines.append('message:')
1538
1613
        if not revision.rev.message:
1539
1614
            lines.append('  (no message)')
1547
1622
        to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1548
1623
        if revision.delta is not None:
1549
1624
            # 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, 
 
1625
            from breezy.delta import report_delta
 
1626
            report_delta(to_file, revision.delta, short_status=False,
1552
1627
                         show_ids=self.show_ids, indent=indent)
1553
1628
        if revision.diff is not None:
1554
1629
            to_file.write(indent + 'diff:\n')
1586
1661
        indent = '    ' * depth
1587
1662
        revno_width = self.revno_width_by_depth.get(depth)
1588
1663
        if revno_width is None:
1589
 
            if revision.revno.find('.') == -1:
 
1664
            if revision.revno is None or revision.revno.find('.') == -1:
1590
1665
                # mainline revno, e.g. 12345
1591
1666
                revno_width = 5
1592
1667
            else:
1600
1675
        if revision.tags:
1601
1676
            tags = ' {%s}' % (', '.join(revision.tags))
1602
1677
        to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1603
 
                revision.revno, self.short_author(revision.rev),
 
1678
                revision.revno or "", self.short_author(revision.rev),
1604
1679
                format_date(revision.rev.timestamp,
1605
1680
                            revision.rev.timezone or 0,
1606
1681
                            self.show_timezone, date_fmt="%Y-%m-%d",
1607
1682
                            show_offset=False),
1608
1683
                tags, self.merge_marker(revision)))
1609
1684
        self.show_properties(revision.rev, indent+offset)
1610
 
        if self.show_ids:
 
1685
        if self.show_ids or revision.revno is None:
1611
1686
            to_file.write(indent + offset + 'revision-id:%s\n'
1612
1687
                          % (revision.rev.revision_id,))
1613
1688
        if not revision.rev.message:
1619
1694
 
1620
1695
        if revision.delta is not None:
1621
1696
            # 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, 
 
1697
            from breezy.delta import report_delta
 
1698
            report_delta(to_file, revision.delta,
 
1699
                         short_status=self.delta_format==1,
1625
1700
                         show_ids=self.show_ids, indent=indent + offset)
1626
1701
        if revision.diff is not None:
1627
1702
            self.show_diff(self.to_exact_file, revision.diff, '      ')
1666
1741
 
1667
1742
    def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1668
1743
        """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
 
1744
 
 
1745
        :param revno:      revision number or None.
 
1746
                           Revision numbers counts from 1.
 
1747
        :param rev:        revision object
 
1748
        :param max_chars:  maximum length of resulting string
 
1749
        :param tags:       list of tags or None
 
1750
        :param prefix:     string to prefix each line
 
1751
        :return:           formatted truncated string
1676
1752
        """
1677
1753
        out = []
1678
1754
        if revno:
1679
1755
            # show revno only when is not None
1680
1756
            out.append("%s:" % revno)
1681
 
        out.append(self.truncate(self.short_author(rev), 20))
 
1757
        if max_chars is not None:
 
1758
            out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
 
1759
        else:
 
1760
            out.append(self.short_author(rev))
1682
1761
        out.append(self.date_string(rev))
1683
1762
        if len(rev.parent_ids) > 1:
1684
1763
            out.append('[merge]')
1703
1782
                               self.show_timezone,
1704
1783
                               date_fmt='%Y-%m-%d',
1705
1784
                               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))
 
1785
        committer_str = self.authors(revision.rev, 'first', sep=', ')
 
1786
        committer_str = committer_str.replace(' <', '  <')
 
1787
        to_file.write('%s  %s\n\n' % (date_str, committer_str))
1708
1788
 
1709
1789
        if revision.delta is not None and revision.delta.has_changed():
1710
1790
            for c in revision.delta.added + revision.delta.removed + revision.delta.modified:
1711
1791
                path, = c[:1]
1712
1792
                to_file.write('\t* %s:\n' % (path,))
1713
1793
            for c in revision.delta.renamed:
1714
 
                oldpath,newpath = c[:2]
 
1794
                oldpath, newpath = c[:2]
1715
1795
                # For renamed files, show both the old and the new path
1716
 
                to_file.write('\t* %s:\n\t* %s:\n' % (oldpath,newpath))
 
1796
                to_file.write('\t* %s:\n\t* %s:\n' % (oldpath, newpath))
1717
1797
            to_file.write('\n')
1718
1798
 
1719
1799
        if not revision.rev.message:
1742
1822
        return self.get(name)(*args, **kwargs)
1743
1823
 
1744
1824
    def get_default(self, branch):
1745
 
        return self.get(branch.get_config().log_format())
 
1825
        c = branch.get_config_stack()
 
1826
        return self.get(c.get('log_format'))
1746
1827
 
1747
1828
 
1748
1829
log_formatter_registry = LogFormatterRegistry()
1749
1830
 
1750
1831
 
1751
1832
log_formatter_registry.register('short', ShortLogFormatter,
1752
 
                                'Moderately short log format')
 
1833
                                'Moderately short log format.')
1753
1834
log_formatter_registry.register('long', LongLogFormatter,
1754
 
                                'Detailed log format')
 
1835
                                'Detailed log format.')
1755
1836
log_formatter_registry.register('line', LineLogFormatter,
1756
 
                                'Log format with one line per revision')
 
1837
                                'Log format with one line per revision.')
1757
1838
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1758
 
                                'Format used by GNU ChangeLog files')
 
1839
                                'Format used by GNU ChangeLog files.')
1759
1840
 
1760
1841
 
1761
1842
def register_formatter(name, formatter):
1771
1852
    try:
1772
1853
        return log_formatter_registry.make_formatter(name, *args, **kwargs)
1773
1854
    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)
 
1855
        raise errors.BzrCommandError(gettext("unknown log formatter: %r") % name)
 
1856
 
 
1857
 
 
1858
def author_list_all(rev):
 
1859
    return rev.get_apparent_authors()[:]
 
1860
 
 
1861
 
 
1862
def author_list_first(rev):
 
1863
    lst = rev.get_apparent_authors()
 
1864
    try:
 
1865
        return [lst[0]]
 
1866
    except IndexError:
 
1867
        return []
 
1868
 
 
1869
 
 
1870
def author_list_committer(rev):
 
1871
    return [rev.committer]
 
1872
 
 
1873
 
 
1874
author_list_registry = registry.Registry()
 
1875
 
 
1876
author_list_registry.register('all', author_list_all,
 
1877
                              'All authors')
 
1878
 
 
1879
author_list_registry.register('first', author_list_first,
 
1880
                              'The first author')
 
1881
 
 
1882
author_list_registry.register('committer', author_list_committer,
 
1883
                              'The committer')
1781
1884
 
1782
1885
 
1783
1886
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1800
1903
    # This is the first index which is different between
1801
1904
    # old and new
1802
1905
    base_idx = None
1803
 
    for i in xrange(max(len(new_rh),
1804
 
                        len(old_rh))):
 
1906
    for i in range(max(len(new_rh), len(old_rh))):
1805
1907
        if (len(new_rh) <= i
1806
1908
            or len(old_rh) <= i
1807
1909
            or new_rh[i] != old_rh[i]):
1848
1950
    old_revisions = set()
1849
1951
    new_history = []
1850
1952
    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)
 
1953
    graph = repository.get_graph()
 
1954
    new_iter = graph.iter_lefthand_ancestry(new_revision_id)
 
1955
    old_iter = graph.iter_lefthand_ancestry(old_revision_id)
1853
1956
    stop_revision = None
1854
1957
    do_old = True
1855
1958
    do_new = True
1856
1959
    while do_new or do_old:
1857
1960
        if do_new:
1858
1961
            try:
1859
 
                new_revision = new_iter.next()
 
1962
                new_revision = next(new_iter)
1860
1963
            except StopIteration:
1861
1964
                do_new = False
1862
1965
            else:
1867
1970
                    break
1868
1971
        if do_old:
1869
1972
            try:
1870
 
                old_revision = old_iter.next()
 
1973
                old_revision = next(old_iter)
1871
1974
            except StopIteration:
1872
1975
                do_old = False
1873
1976
            else:
1912
2015
        output.write('Added Revisions:\n')
1913
2016
        start_revno = new_revno - len(new_history) + 1
1914
2017
        show_log(branch, lf, None, verbose=False, direction='forward',
1915
 
                 start_revision=start_revno,)
 
2018
                 start_revision=start_revno)
1916
2019
 
1917
2020
 
1918
2021
def show_flat_log(repository, history, last_revno, lf):
1930
2033
        lf.log_revision(lr)
1931
2034
 
1932
2035
 
1933
 
def _get_info_for_log_files(revisionspec_list, file_list):
 
2036
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
1934
2037
    """Find file-ids and kinds given a list of files and a revision range.
1935
2038
 
1936
2039
    We search for files at the end of the range. If not found there,
1940
2043
    :param file_list: the list of paths given on the command line;
1941
2044
      the first of these can be a branch location or a file path,
1942
2045
      the remainder must be file paths
 
2046
    :param add_cleanup: When the branch returned is read locked,
 
2047
      an unlock call will be queued to the cleanup.
1943
2048
    :return: (branch, info_list, start_rev_info, end_rev_info) where
1944
2049
      info_list is a list of (relative_path, file_id, kind) tuples where
1945
2050
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1946
2051
      branch will be read-locked.
1947
2052
    """
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()
 
2053
    from breezy.builtins import _get_revision_range
 
2054
    tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
 
2055
        file_list[0])
 
2056
    add_cleanup(b.lock_read().unlock)
1951
2057
    # XXX: It's damn messy converting a list of paths to relative paths when
1952
2058
    # those paths might be deleted ones, they might be on a case-insensitive
1953
2059
    # filesystem and/or they might be in silly locations (like another branch).
1957
2063
    # case of running log in a nested directory, assuming paths beyond the
1958
2064
    # first one haven't been deleted ...
1959
2065
    if tree:
1960
 
        relpaths = [path] + safe_relpath_files(tree, file_list[1:])
 
2066
        relpaths = [path] + tree.safe_relpath_files(file_list[1:])
1961
2067
    else:
1962
2068
        relpaths = [path] + file_list[1:]
1963
2069
    info_list = []
1971
2077
        tree1 = None
1972
2078
        for fp in relpaths:
1973
2079
            file_id = tree.path2id(fp)
1974
 
            kind = _get_kind_for_file_id(tree, file_id)
 
2080
            kind = _get_kind_for_file_id(tree, fp, file_id)
1975
2081
            if file_id is None:
1976
2082
                # go back to when time began
1977
2083
                if tree1 is None:
1985
2091
                        tree1 = b.repository.revision_tree(rev1)
1986
2092
                if tree1:
1987
2093
                    file_id = tree1.path2id(fp)
1988
 
                    kind = _get_kind_for_file_id(tree1, file_id)
 
2094
                    kind = _get_kind_for_file_id(tree1, fp, file_id)
1989
2095
            info_list.append((fp, file_id, kind))
1990
2096
 
1991
2097
    elif start_rev_info == end_rev_info:
1993
2099
        tree = b.repository.revision_tree(end_rev_info.rev_id)
1994
2100
        for fp in relpaths:
1995
2101
            file_id = tree.path2id(fp)
1996
 
            kind = _get_kind_for_file_id(tree, file_id)
 
2102
            kind = _get_kind_for_file_id(tree, fp, file_id)
1997
2103
            info_list.append((fp, file_id, kind))
1998
2104
 
1999
2105
    else:
2007
2113
        tree1 = None
2008
2114
        for fp in relpaths:
2009
2115
            file_id = tree.path2id(fp)
2010
 
            kind = _get_kind_for_file_id(tree, file_id)
 
2116
            kind = _get_kind_for_file_id(tree, fp, file_id)
2011
2117
            if file_id is None:
2012
2118
                if tree1 is None:
2013
2119
                    rev_id = start_rev_info.rev_id
2017
2123
                    else:
2018
2124
                        tree1 = b.repository.revision_tree(rev_id)
2019
2125
                file_id = tree1.path2id(fp)
2020
 
                kind = _get_kind_for_file_id(tree1, file_id)
 
2126
                kind = _get_kind_for_file_id(tree1, fp, file_id)
2021
2127
            info_list.append((fp, file_id, kind))
2022
2128
    return b, info_list, start_rev_info, end_rev_info
2023
2129
 
2024
2130
 
2025
 
def _get_kind_for_file_id(tree, file_id):
 
2131
def _get_kind_for_file_id(tree, path, file_id):
2026
2132
    """Return the kind of a file-id or None if it doesn't exist."""
2027
2133
    if file_id is not None:
2028
 
        return tree.kind(file_id)
 
2134
        return tree.kind(path, file_id)
2029
2135
    else:
2030
2136
        return None
2031
2137
 
2034
2140
 
2035
2141
# Use the properties handlers to print out bug information if available
2036
2142
def _bugs_properties_handler(revision):
2037
 
    if revision.properties.has_key('bugs'):
 
2143
    if 'bugs' in revision.properties:
2038
2144
        bug_lines = revision.properties['bugs'].split('\n')
2039
2145
        bug_rows = [line.split(' ', 1) for line in bug_lines]
2040
2146
        fixed_bug_urls = [row[0] for row in bug_rows if
2041
2147
                          len(row) > 1 and row[1] == 'fixed']
2042
2148
 
2043
2149
        if fixed_bug_urls:
2044
 
            return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
 
2150
            return {ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls)):\
 
2151
                    ' '.join(fixed_bug_urls)}
2045
2152
    return {}
2046
2153
 
2047
2154
properties_handler_registry.register('bugs_properties_handler',