/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 11:31:40 UTC
  • mfrom: (7143.12.3 annotated-tags)
  • Revision ID: breezy.the.bot@gmail.com-20181116113140-618u04763u0dyxnh
Fix fetching of revisions that are referenced by annotated tags.

Merged from https://code.launchpad.net/~jelmer/brz/annotated-tags/+merge/358536

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