~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005-2011 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
"""Code to show logs of changes.
20
18
 
42
40
 
43
41
In verbose mode we show a summary of what changed in each particular
44
42
revision.  Note that this is the delta for changes in that revision
45
 
relative to its mainline parent, not the delta relative to the last
 
43
relative to its left-most parent, not the delta relative to the last
46
44
logged revision.  So for example if you ask for a verbose log of
47
45
changes touching hello.c you will get a list of those revisions also
48
46
listing other things that were changed in the same revision, but not
49
47
all the changes since the previous revision that touched hello.c.
50
48
"""
51
49
 
 
50
from __future__ import absolute_import
52
51
 
53
 
import bzrlib.errors as errors
54
 
from bzrlib.tree import EmptyTree
55
 
from bzrlib.delta import compare_trees
56
 
from bzrlib.trace import mutter
 
52
import codecs
 
53
from cStringIO import StringIO
 
54
from itertools import (
 
55
    chain,
 
56
    izip,
 
57
    )
57
58
import re
 
59
import sys
 
60
from warnings import (
 
61
    warn,
 
62
    )
 
63
 
 
64
from bzrlib.lazy_import import lazy_import
 
65
lazy_import(globals(), """
 
66
 
 
67
from bzrlib import (
 
68
    config,
 
69
    controldir,
 
70
    diff,
 
71
    errors,
 
72
    foreign,
 
73
    repository as _mod_repository,
 
74
    revision as _mod_revision,
 
75
    revisionspec,
 
76
    tsort,
 
77
    )
 
78
from bzrlib.i18n import gettext, ngettext
 
79
""")
 
80
 
 
81
from bzrlib import (
 
82
    lazy_regex,
 
83
    registry,
 
84
    )
 
85
from bzrlib.osutils import (
 
86
    format_date,
 
87
    format_date_with_offset_in_original_timezone,
 
88
    get_diff_header_encoding,
 
89
    get_terminal_encoding,
 
90
    terminal_width,
 
91
    )
58
92
 
59
93
 
60
94
def find_touching_revisions(branch, file_id):
71
105
    last_ie = None
72
106
    last_path = None
73
107
    revno = 1
74
 
    for revision_id in branch.revision_history():
75
 
        this_inv = branch.get_revision_inventory(revision_id)
76
 
        if file_id in this_inv:
 
108
    graph = branch.repository.get_graph()
 
109
    history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
 
110
        [_mod_revision.NULL_REVISION]))
 
111
    for revision_id in reversed(history):
 
112
        this_inv = branch.repository.get_inventory(revision_id)
 
113
        if this_inv.has_id(file_id):
77
114
            this_ie = this_inv[file_id]
78
115
            this_path = this_inv.id2path(file_id)
79
116
        else:
101
138
        revno += 1
102
139
 
103
140
 
104
 
 
105
 
def _enumerate_history(branch):
106
 
    rh = []
107
 
    revno = 1
108
 
    for rev_id in branch.revision_history():
109
 
        rh.append((revno, rev_id))
110
 
        revno += 1
111
 
    return rh
112
 
 
113
 
 
114
 
def _get_revision_delta(branch, revno):
115
 
    """Return the delta for a mainline revision.
116
 
    
117
 
    This is used to show summaries in verbose logs, and also for finding 
118
 
    revisions which touch a given file."""
119
 
    # XXX: What are we supposed to do when showing a summary for something 
120
 
    # other than a mainline revision.  The delta to it's first parent, or
121
 
    # (more useful) the delta to a nominated other revision.
122
 
    return branch.get_revision_delta(revno)
123
 
 
124
 
 
125
141
def show_log(branch,
126
142
             lf,
127
143
             specific_fileid=None,
129
145
             direction='reverse',
130
146
             start_revision=None,
131
147
             end_revision=None,
132
 
             search=None):
 
148
             search=None,
 
149
             limit=None,
 
150
             show_diff=False,
 
151
             match=None):
133
152
    """Write out human-readable log of commits to this branch.
134
153
 
135
 
    lf
136
 
        LogFormatter object to show the output.
137
 
 
138
 
    specific_fileid
139
 
        If true, list only the commits affecting the specified
140
 
        file, rather than all commits.
141
 
 
142
 
    verbose
143
 
        If true show added/changed/deleted/renamed files.
144
 
 
145
 
    direction
146
 
        'reverse' (default) is latest to earliest;
147
 
        'forward' is earliest to latest.
148
 
 
149
 
    start_revision
150
 
        If not None, only show revisions >= start_revision
151
 
 
152
 
    end_revision
153
 
        If not None, only show revisions <= end_revision
154
 
    """
155
 
    branch.lock_read()
 
154
    This function is being retained for backwards compatibility but
 
155
    should not be extended with new parameters. Use the new Logger class
 
156
    instead, eg. Logger(branch, rqst).show(lf), adding parameters to the
 
157
    make_log_request_dict function.
 
158
 
 
159
    :param lf: The LogFormatter object showing the output.
 
160
 
 
161
    :param specific_fileid: If not None, list only the commits affecting the
 
162
        specified file, rather than all commits.
 
163
 
 
164
    :param verbose: If True show added/changed/deleted/renamed files.
 
165
 
 
166
    :param direction: 'reverse' (default) is latest to earliest; 'forward' is
 
167
        earliest to latest.
 
168
 
 
169
    :param start_revision: If not None, only show revisions >= start_revision
 
170
 
 
171
    :param end_revision: If not None, only show revisions <= end_revision
 
172
 
 
173
    :param search: If not None, only show revisions with matching commit
 
174
        messages
 
175
 
 
176
    :param limit: If set, shows only 'limit' revisions, all revisions are shown
 
177
        if None or 0.
 
178
 
 
179
    :param show_diff: If True, output a diff after each revision.
 
180
 
 
181
    :param match: Dictionary of search lists to use when matching revision
 
182
      properties.
 
183
    """
 
184
    # Convert old-style parameters to new-style parameters
 
185
    if specific_fileid is not None:
 
186
        file_ids = [specific_fileid]
 
187
    else:
 
188
        file_ids = None
 
189
    if verbose:
 
190
        if file_ids:
 
191
            delta_type = 'partial'
 
192
        else:
 
193
            delta_type = 'full'
 
194
    else:
 
195
        delta_type = None
 
196
    if show_diff:
 
197
        if file_ids:
 
198
            diff_type = 'partial'
 
199
        else:
 
200
            diff_type = 'full'
 
201
    else:
 
202
        diff_type = None
 
203
 
 
204
    # Build the request and execute it
 
205
    rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
 
206
        start_revision=start_revision, end_revision=end_revision,
 
207
        limit=limit, message_search=search,
 
208
        delta_type=delta_type, diff_type=diff_type)
 
209
    Logger(branch, rqst).show(lf)
 
210
 
 
211
 
 
212
# Note: This needs to be kept in sync with the defaults in
 
213
# make_log_request_dict() below
 
214
_DEFAULT_REQUEST_PARAMS = {
 
215
    'direction': 'reverse',
 
216
    'levels': None,
 
217
    'generate_tags': True,
 
218
    'exclude_common_ancestry': False,
 
219
    '_match_using_deltas': True,
 
220
    }
 
221
 
 
222
 
 
223
def make_log_request_dict(direction='reverse', specific_fileids=None,
 
224
                          start_revision=None, end_revision=None, limit=None,
 
225
                          message_search=None, levels=None, generate_tags=True,
 
226
                          delta_type=None,
 
227
                          diff_type=None, _match_using_deltas=True,
 
228
                          exclude_common_ancestry=False, match=None,
 
229
                          signature=False, omit_merges=False,
 
230
                          ):
 
231
    """Convenience function for making a logging request dictionary.
 
232
 
 
233
    Using this function may make code slightly safer by ensuring
 
234
    parameters have the correct names. It also provides a reference
 
235
    point for documenting the supported parameters.
 
236
 
 
237
    :param direction: 'reverse' (default) is latest to earliest;
 
238
      'forward' is earliest to latest.
 
239
 
 
240
    :param specific_fileids: If not None, only include revisions
 
241
      affecting the specified files, rather than all revisions.
 
242
 
 
243
    :param start_revision: If not None, only generate
 
244
      revisions >= start_revision
 
245
 
 
246
    :param end_revision: If not None, only generate
 
247
      revisions <= end_revision
 
248
 
 
249
    :param limit: If set, generate only 'limit' revisions, all revisions
 
250
      are shown if None or 0.
 
251
 
 
252
    :param message_search: If not None, only include revisions with
 
253
      matching commit messages
 
254
 
 
255
    :param levels: the number of levels of revisions to
 
256
      generate; 1 for just the mainline; 0 for all levels, or None for
 
257
      a sensible default.
 
258
 
 
259
    :param generate_tags: If True, include tags for matched revisions.
 
260
`
 
261
    :param delta_type: Either 'full', 'partial' or None.
 
262
      'full' means generate the complete delta - adds/deletes/modifies/etc;
 
263
      'partial' means filter the delta using specific_fileids;
 
264
      None means do not generate any delta.
 
265
 
 
266
    :param diff_type: Either 'full', 'partial' or None.
 
267
      'full' means generate the complete diff - adds/deletes/modifies/etc;
 
268
      'partial' means filter the diff using specific_fileids;
 
269
      None means do not generate any diff.
 
270
 
 
271
    :param _match_using_deltas: a private parameter controlling the
 
272
      algorithm used for matching specific_fileids. This parameter
 
273
      may be removed in the future so bzrlib client code should NOT
 
274
      use it.
 
275
 
 
276
    :param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
 
277
      range operator or as a graph difference.
 
278
 
 
279
    :param signature: show digital signature information
 
280
 
 
281
    :param match: Dictionary of list of search strings to use when filtering
 
282
      revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
 
283
      the empty string to match any of the preceding properties.
 
284
 
 
285
    :param omit_merges: If True, commits with more than one parent are
 
286
      omitted.
 
287
 
 
288
    """
 
289
    # Take care of old style message_search parameter
 
290
    if message_search:
 
291
        if match:
 
292
            if 'message' in match:
 
293
                match['message'].append(message_search)
 
294
            else:
 
295
                match['message'] = [message_search]
 
296
        else:
 
297
            match={ 'message': [message_search] }
 
298
    return {
 
299
        'direction': direction,
 
300
        'specific_fileids': specific_fileids,
 
301
        'start_revision': start_revision,
 
302
        'end_revision': end_revision,
 
303
        'limit': limit,
 
304
        'levels': levels,
 
305
        'generate_tags': generate_tags,
 
306
        'delta_type': delta_type,
 
307
        'diff_type': diff_type,
 
308
        'exclude_common_ancestry': exclude_common_ancestry,
 
309
        'signature': signature,
 
310
        'match': match,
 
311
        'omit_merges': omit_merges,
 
312
        # Add 'private' attributes for features that may be deprecated
 
313
        '_match_using_deltas': _match_using_deltas,
 
314
    }
 
315
 
 
316
 
 
317
def _apply_log_request_defaults(rqst):
 
318
    """Apply default values to a request dictionary."""
 
319
    result = _DEFAULT_REQUEST_PARAMS.copy()
 
320
    if rqst:
 
321
        result.update(rqst)
 
322
    return result
 
323
 
 
324
 
 
325
def format_signature_validity(rev_id, repo):
 
326
    """get the signature validity
 
327
 
 
328
    :param rev_id: revision id to validate
 
329
    :param repo: repository of revision
 
330
    :return: human readable string to print to log
 
331
    """
 
332
    from bzrlib import gpg
 
333
 
 
334
    gpg_strategy = gpg.GPGStrategy(None)
 
335
    result = repo.verify_revision_signature(rev_id, gpg_strategy)
 
336
    if result[0] == gpg.SIGNATURE_VALID:
 
337
        return u"valid signature from {0}".format(result[1])
 
338
    if result[0] == gpg.SIGNATURE_KEY_MISSING:
 
339
        return "unknown key {0}".format(result[1])
 
340
    if result[0] == gpg.SIGNATURE_NOT_VALID:
 
341
        return "invalid signature!"
 
342
    if result[0] == gpg.SIGNATURE_NOT_SIGNED:
 
343
        return "no signature"
 
344
 
 
345
 
 
346
class LogGenerator(object):
 
347
    """A generator of log revisions."""
 
348
 
 
349
    def iter_log_revisions(self):
 
350
        """Iterate over LogRevision objects.
 
351
 
 
352
        :return: An iterator yielding LogRevision objects.
 
353
        """
 
354
        raise NotImplementedError(self.iter_log_revisions)
 
355
 
 
356
 
 
357
class Logger(object):
 
358
    """An object that generates, formats and displays a log."""
 
359
 
 
360
    def __init__(self, branch, rqst):
 
361
        """Create a Logger.
 
362
 
 
363
        :param branch: the branch to log
 
364
        :param rqst: A dictionary specifying the query parameters.
 
365
          See make_log_request_dict() for supported values.
 
366
        """
 
367
        self.branch = branch
 
368
        self.rqst = _apply_log_request_defaults(rqst)
 
369
 
 
370
    def show(self, lf):
 
371
        """Display the log.
 
372
 
 
373
        :param lf: The LogFormatter object to send the output to.
 
374
        """
 
375
        if not isinstance(lf, LogFormatter):
 
376
            warn("not a LogFormatter instance: %r" % lf)
 
377
 
 
378
        self.branch.lock_read()
 
379
        try:
 
380
            if getattr(lf, 'begin_log', None):
 
381
                lf.begin_log()
 
382
            self._show_body(lf)
 
383
            if getattr(lf, 'end_log', None):
 
384
                lf.end_log()
 
385
        finally:
 
386
            self.branch.unlock()
 
387
 
 
388
    def _show_body(self, lf):
 
389
        """Show the main log output.
 
390
 
 
391
        Subclasses may wish to override this.
 
392
        """
 
393
        # Tweak the LogRequest based on what the LogFormatter can handle.
 
394
        # (There's no point generating stuff if the formatter can't display it.)
 
395
        rqst = self.rqst
 
396
        if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
 
397
            # user didn't specify levels, use whatever the LF can handle:
 
398
            rqst['levels'] = lf.get_levels()
 
399
 
 
400
        if not getattr(lf, 'supports_tags', False):
 
401
            rqst['generate_tags'] = False
 
402
        if not getattr(lf, 'supports_delta', False):
 
403
            rqst['delta_type'] = None
 
404
        if not getattr(lf, 'supports_diff', False):
 
405
            rqst['diff_type'] = None
 
406
        if not getattr(lf, 'supports_signatures', False):
 
407
            rqst['signature'] = False
 
408
 
 
409
        # Find and print the interesting revisions
 
410
        generator = self._generator_factory(self.branch, rqst)
 
411
        for lr in generator.iter_log_revisions():
 
412
            lf.log_revision(lr)
 
413
        lf.show_advice()
 
414
 
 
415
    def _generator_factory(self, branch, rqst):
 
416
        """Make the LogGenerator object to use.
 
417
 
 
418
        Subclasses may wish to override this.
 
419
        """
 
420
        return _DefaultLogGenerator(branch, rqst)
 
421
 
 
422
 
 
423
class _StartNotLinearAncestor(Exception):
 
424
    """Raised when a start revision is not found walking left-hand history."""
 
425
 
 
426
 
 
427
class _DefaultLogGenerator(LogGenerator):
 
428
    """The default generator of log revisions."""
 
429
 
 
430
    def __init__(self, branch, rqst):
 
431
        self.branch = branch
 
432
        self.rqst = rqst
 
433
        if rqst.get('generate_tags') and branch.supports_tags():
 
434
            self.rev_tag_dict = branch.tags.get_reverse_tag_dict()
 
435
        else:
 
436
            self.rev_tag_dict = {}
 
437
 
 
438
    def iter_log_revisions(self):
 
439
        """Iterate over LogRevision objects.
 
440
 
 
441
        :return: An iterator yielding LogRevision objects.
 
442
        """
 
443
        rqst = self.rqst
 
444
        levels = rqst.get('levels')
 
445
        limit = rqst.get('limit')
 
446
        diff_type = rqst.get('diff_type')
 
447
        show_signature = rqst.get('signature')
 
448
        omit_merges = rqst.get('omit_merges')
 
449
        log_count = 0
 
450
        revision_iterator = self._create_log_revision_iterator()
 
451
        for revs in revision_iterator:
 
452
            for (rev_id, revno, merge_depth), rev, delta in revs:
 
453
                # 0 levels means show everything; merge_depth counts from 0
 
454
                if levels != 0 and merge_depth >= levels:
 
455
                    continue
 
456
                if omit_merges and len(rev.parent_ids) > 1:
 
457
                    continue
 
458
                if diff_type is None:
 
459
                    diff = None
 
460
                else:
 
461
                    diff = self._format_diff(rev, rev_id, diff_type)
 
462
                if show_signature:
 
463
                    signature = format_signature_validity(rev_id,
 
464
                                                self.branch.repository)
 
465
                else:
 
466
                    signature = None
 
467
                yield LogRevision(rev, revno, merge_depth, delta,
 
468
                    self.rev_tag_dict.get(rev_id), diff, signature)
 
469
                if limit:
 
470
                    log_count += 1
 
471
                    if log_count >= limit:
 
472
                        return
 
473
 
 
474
    def _format_diff(self, rev, rev_id, diff_type):
 
475
        repo = self.branch.repository
 
476
        if len(rev.parent_ids) == 0:
 
477
            ancestor_id = _mod_revision.NULL_REVISION
 
478
        else:
 
479
            ancestor_id = rev.parent_ids[0]
 
480
        tree_1 = repo.revision_tree(ancestor_id)
 
481
        tree_2 = repo.revision_tree(rev_id)
 
482
        file_ids = self.rqst.get('specific_fileids')
 
483
        if diff_type == 'partial' and file_ids is not None:
 
484
            specific_files = [tree_2.id2path(id) for id in file_ids]
 
485
        else:
 
486
            specific_files = None
 
487
        s = StringIO()
 
488
        path_encoding = get_diff_header_encoding()
 
489
        diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
 
490
            new_label='', path_encoding=path_encoding)
 
491
        return s.getvalue()
 
492
 
 
493
    def _create_log_revision_iterator(self):
 
494
        """Create a revision iterator for log.
 
495
 
 
496
        :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
 
497
            delta).
 
498
        """
 
499
        self.start_rev_id, self.end_rev_id = _get_revision_limits(
 
500
            self.branch, self.rqst.get('start_revision'),
 
501
            self.rqst.get('end_revision'))
 
502
        if self.rqst.get('_match_using_deltas'):
 
503
            return self._log_revision_iterator_using_delta_matching()
 
504
        else:
 
505
            # We're using the per-file-graph algorithm. This scales really
 
506
            # well but only makes sense if there is a single file and it's
 
507
            # not a directory
 
508
            file_count = len(self.rqst.get('specific_fileids'))
 
509
            if file_count != 1:
 
510
                raise BzrError("illegal LogRequest: must match-using-deltas "
 
511
                    "when logging %d files" % file_count)
 
512
            return self._log_revision_iterator_using_per_file_graph()
 
513
 
 
514
    def _log_revision_iterator_using_delta_matching(self):
 
515
        # Get the base revisions, filtering by the revision range
 
516
        rqst = self.rqst
 
517
        generate_merge_revisions = rqst.get('levels') != 1
 
518
        delayed_graph_generation = not rqst.get('specific_fileids') and (
 
519
                rqst.get('limit') or self.start_rev_id or self.end_rev_id)
 
520
        view_revisions = _calc_view_revisions(
 
521
            self.branch, self.start_rev_id, self.end_rev_id,
 
522
            rqst.get('direction'),
 
523
            generate_merge_revisions=generate_merge_revisions,
 
524
            delayed_graph_generation=delayed_graph_generation,
 
525
            exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
 
526
 
 
527
        # Apply the other filters
 
528
        return make_log_rev_iterator(self.branch, view_revisions,
 
529
            rqst.get('delta_type'), rqst.get('match'),
 
530
            file_ids=rqst.get('specific_fileids'),
 
531
            direction=rqst.get('direction'))
 
532
 
 
533
    def _log_revision_iterator_using_per_file_graph(self):
 
534
        # Get the base revisions, filtering by the revision range.
 
535
        # Note that we always generate the merge revisions because
 
536
        # filter_revisions_touching_file_id() requires them ...
 
537
        rqst = self.rqst
 
538
        view_revisions = _calc_view_revisions(
 
539
            self.branch, self.start_rev_id, self.end_rev_id,
 
540
            rqst.get('direction'), generate_merge_revisions=True,
 
541
            exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
 
542
        if not isinstance(view_revisions, list):
 
543
            view_revisions = list(view_revisions)
 
544
        view_revisions = _filter_revisions_touching_file_id(self.branch,
 
545
            rqst.get('specific_fileids')[0], view_revisions,
 
546
            include_merges=rqst.get('levels') != 1)
 
547
        return make_log_rev_iterator(self.branch, view_revisions,
 
548
            rqst.get('delta_type'), rqst.get('match'))
 
549
 
 
550
 
 
551
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
 
552
                         generate_merge_revisions,
 
553
                         delayed_graph_generation=False,
 
554
                         exclude_common_ancestry=False,
 
555
                         ):
 
556
    """Calculate the revisions to view.
 
557
 
 
558
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
 
559
             a list of the same tuples.
 
560
    """
 
561
    if (exclude_common_ancestry and start_rev_id == end_rev_id):
 
562
        raise errors.BzrCommandError(gettext(
 
563
            '--exclude-common-ancestry requires two different revisions'))
 
564
    if direction not in ('reverse', 'forward'):
 
565
        raise ValueError(gettext('invalid direction %r') % direction)
 
566
    br_revno, br_rev_id = branch.last_revision_info()
 
567
    if br_revno == 0:
 
568
        return []
 
569
 
 
570
    if (end_rev_id and start_rev_id == end_rev_id
 
571
        and (not generate_merge_revisions
 
572
             or not _has_merges(branch, end_rev_id))):
 
573
        # If a single revision is requested, check we can handle it
 
574
        return  _generate_one_revision(branch, end_rev_id, br_rev_id,
 
575
                                       br_revno)
 
576
    if not generate_merge_revisions:
 
577
        try:
 
578
            # If we only want to see linear revisions, we can iterate ...
 
579
            iter_revs = _linear_view_revisions(
 
580
                branch, start_rev_id, end_rev_id,
 
581
                exclude_common_ancestry=exclude_common_ancestry)
 
582
            # If a start limit was given and it's not obviously an
 
583
            # ancestor of the end limit, check it before outputting anything
 
584
            if (direction == 'forward'
 
585
                or (start_rev_id and not _is_obvious_ancestor(
 
586
                        branch, start_rev_id, end_rev_id))):
 
587
                    iter_revs = list(iter_revs)
 
588
            if direction == 'forward':
 
589
                iter_revs = reversed(iter_revs)
 
590
            return iter_revs
 
591
        except _StartNotLinearAncestor:
 
592
            # Switch to the slower implementation that may be able to find a
 
593
            # non-obvious ancestor out of the left-hand history.
 
594
            pass
 
595
    iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
 
596
                                        direction, delayed_graph_generation,
 
597
                                        exclude_common_ancestry)
 
598
    if direction == 'forward':
 
599
        iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
 
600
    return iter_revs
 
601
 
 
602
 
 
603
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):
 
604
    if rev_id == br_rev_id:
 
605
        # It's the tip
 
606
        return [(br_rev_id, br_revno, 0)]
 
607
    else:
 
608
        revno_str = _compute_revno_str(branch, rev_id)
 
609
        return [(rev_id, revno_str, 0)]
 
610
 
 
611
 
 
612
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
 
613
                            delayed_graph_generation,
 
614
                            exclude_common_ancestry=False):
 
615
    # On large trees, generating the merge graph can take 30-60 seconds
 
616
    # so we delay doing it until a merge is detected, incrementally
 
617
    # returning initial (non-merge) revisions while we can.
 
618
 
 
619
    # The above is only true for old formats (<= 0.92), for newer formats, a
 
620
    # couple of seconds only should be needed to load the whole graph and the
 
621
    # other graph operations needed are even faster than that -- vila 100201
 
622
    initial_revisions = []
 
623
    if delayed_graph_generation:
 
624
        try:
 
625
            for rev_id, revno, depth in  _linear_view_revisions(
 
626
                branch, start_rev_id, end_rev_id, exclude_common_ancestry):
 
627
                if _has_merges(branch, rev_id):
 
628
                    # The end_rev_id can be nested down somewhere. We need an
 
629
                    # explicit ancestry check. There is an ambiguity here as we
 
630
                    # may not raise _StartNotLinearAncestor for a revision that
 
631
                    # is an ancestor but not a *linear* one. But since we have
 
632
                    # loaded the graph to do the check (or calculate a dotted
 
633
                    # revno), we may as well accept to show the log...  We need
 
634
                    # the check only if start_rev_id is not None as all
 
635
                    # revisions have _mod_revision.NULL_REVISION as an ancestor
 
636
                    # -- vila 20100319
 
637
                    graph = branch.repository.get_graph()
 
638
                    if (start_rev_id is not None
 
639
                        and not graph.is_ancestor(start_rev_id, end_rev_id)):
 
640
                        raise _StartNotLinearAncestor()
 
641
                    # Since we collected the revisions so far, we need to
 
642
                    # adjust end_rev_id.
 
643
                    end_rev_id = rev_id
 
644
                    break
 
645
                else:
 
646
                    initial_revisions.append((rev_id, revno, depth))
 
647
            else:
 
648
                # No merged revisions found
 
649
                return initial_revisions
 
650
        except _StartNotLinearAncestor:
 
651
            # A merge was never detected so the lower revision limit can't
 
652
            # be nested down somewhere
 
653
            raise errors.BzrCommandError(gettext('Start revision not found in'
 
654
                ' history of end revision.'))
 
655
 
 
656
    # We exit the loop above because we encounter a revision with merges, from
 
657
    # this revision, we need to switch to _graph_view_revisions.
 
658
 
 
659
    # A log including nested merges is required. If the direction is reverse,
 
660
    # we rebase the initial merge depths so that the development line is
 
661
    # shown naturally, i.e. just like it is for linear logging. We can easily
 
662
    # make forward the exact opposite display, but showing the merge revisions
 
663
    # indented at the end seems slightly nicer in that case.
 
664
    view_revisions = chain(iter(initial_revisions),
 
665
        _graph_view_revisions(branch, start_rev_id, end_rev_id,
 
666
                              rebase_initial_depths=(direction == 'reverse'),
 
667
                              exclude_common_ancestry=exclude_common_ancestry))
 
668
    return view_revisions
 
669
 
 
670
 
 
671
def _has_merges(branch, rev_id):
 
672
    """Does a revision have multiple parents or not?"""
 
673
    parents = branch.repository.get_parent_map([rev_id]).get(rev_id, [])
 
674
    return len(parents) > 1
 
675
 
 
676
 
 
677
def _compute_revno_str(branch, rev_id):
 
678
    """Compute the revno string from a rev_id.
 
679
 
 
680
    :return: The revno string, or None if the revision is not in the supplied
 
681
        branch.
 
682
    """
156
683
    try:
157
 
        _show_log(branch, lf, specific_fileid, verbose, direction,
158
 
                  start_revision, end_revision, search)
159
 
    finally:
160
 
        branch.unlock()
161
 
    
162
 
def _show_log(branch,
163
 
             lf,
164
 
             specific_fileid=None,
165
 
             verbose=False,
166
 
             direction='reverse',
167
 
             start_revision=None,
168
 
             end_revision=None,
169
 
             search=None):
170
 
    """Worker function for show_log - see show_log."""
171
 
    from bzrlib.osutils import format_date
172
 
    from bzrlib.errors import BzrCheckError
173
 
    from bzrlib.textui import show_status
174
 
    
175
 
    from warnings import warn
176
 
 
177
 
    if not isinstance(lf, LogFormatter):
178
 
        warn("not a LogFormatter instance: %r" % lf)
179
 
 
180
 
    if specific_fileid:
181
 
        mutter('get log for file_id %r' % specific_fileid)
182
 
 
183
 
    if search is not None:
184
 
        import re
185
 
        searchRE = re.compile(search, re.IGNORECASE)
186
 
    else:
187
 
        searchRE = None
188
 
 
189
 
    which_revs = _enumerate_history(branch)
190
 
    
191
 
    if start_revision is None:
192
 
        start_revision = 1
193
 
    else:
194
 
        branch.check_real_revno(start_revision)
195
 
    
196
 
    if end_revision is None:
197
 
        end_revision = len(which_revs)
198
 
    else:
199
 
        branch.check_real_revno(end_revision)
200
 
 
201
 
    # list indexes are 0-based; revisions are 1-based
202
 
    cut_revs = which_revs[(start_revision-1):(end_revision)]
203
 
 
204
 
    if direction == 'reverse':
205
 
        cut_revs.reverse()
206
 
    elif direction == 'forward':
207
 
        pass
208
 
    else:
209
 
        raise ValueError('invalid direction %r' % direction)
210
 
 
211
 
    revision_history = branch.revision_history()
212
 
    for revno, rev_id in cut_revs:
213
 
        if verbose or specific_fileid:
214
 
            delta = _get_revision_delta(branch, revno)
215
 
            
216
 
        if specific_fileid:
217
 
            if not delta.touches_file_id(specific_fileid):
218
 
                continue
219
 
 
220
 
        if not verbose:
221
 
            # although we calculated it, throw it away without display
222
 
            delta = None
223
 
 
224
 
        rev = branch.get_revision(rev_id)
225
 
 
226
 
        if searchRE:
227
 
            if not searchRE.search(rev.message):
228
 
                continue
229
 
 
230
 
        lf.show(revno, rev, delta)
231
 
        if hasattr(lf, 'show_merge'):
232
 
            if revno == 1:
233
 
                excludes = set()
234
 
            else:
235
 
                # revno is 1 based, so -2 to get back 1 less.
236
 
                excludes = set(branch.get_ancestry(revision_history[revno - 2]))
237
 
            pending = list(rev.parent_ids)
238
 
            while pending:
239
 
                rev_id = pending.pop()
240
 
                if rev_id in excludes:
241
 
                    continue
242
 
                # prevent showing merged revs twice if they multi-path.
243
 
                excludes.add(rev_id)
244
 
                try:
245
 
                    rev = branch.get_revision(rev_id)
246
 
                except errors.NoSuchRevision:
247
 
                    continue
248
 
                pending.extend(rev.parent_ids)
249
 
                lf.show_merge(rev)
250
 
 
251
 
 
252
 
def deltas_for_log_dummy(branch, which_revs):
253
 
    """Return all the revisions without intermediate deltas.
254
 
 
255
 
    Useful for log commands that won't need the delta information.
256
 
    """
257
 
    
258
 
    for revno, revision_id in which_revs:
259
 
        yield revno, branch.get_revision(revision_id), None
260
 
 
261
 
 
262
 
def deltas_for_log_reverse(branch, which_revs):
263
 
    """Compute deltas for display in latest-to-earliest order.
264
 
 
265
 
    branch
266
 
        Branch to traverse
267
 
 
268
 
    which_revs
269
 
        Sequence of (revno, revision_id) for the subset of history to examine
270
 
 
271
 
    returns 
272
 
        Sequence of (revno, rev, delta)
273
 
 
274
 
    The delta is from the given revision to the next one in the
275
 
    sequence, which makes sense if the log is being displayed from
276
 
    newest to oldest.
277
 
    """
278
 
    last_revno = last_revision_id = last_tree = None
279
 
    for revno, revision_id in which_revs:
280
 
        this_tree = branch.revision_tree(revision_id)
281
 
        this_revision = branch.get_revision(revision_id)
282
 
        
283
 
        if last_revno:
284
 
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
285
 
 
286
 
        this_tree = EmptyTree(branch.get_root_id())
287
 
 
288
 
        last_revno = revno
289
 
        last_revision = this_revision
290
 
        last_tree = this_tree
291
 
 
292
 
    if last_revno:
293
 
        if last_revno == 1:
294
 
            this_tree = EmptyTree(branch.get_root_id())
295
 
        else:
296
 
            this_revno = last_revno - 1
297
 
            this_revision_id = branch.revision_history()[this_revno]
298
 
            this_tree = branch.revision_tree(this_revision_id)
299
 
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
300
 
 
301
 
 
302
 
def deltas_for_log_forward(branch, which_revs):
303
 
    """Compute deltas for display in forward log.
304
 
 
305
 
    Given a sequence of (revno, revision_id) pairs, return
306
 
    (revno, rev, delta).
307
 
 
308
 
    The delta is from the given revision to the next one in the
309
 
    sequence, which makes sense if the log is being displayed from
310
 
    newest to oldest.
311
 
    """
312
 
    last_revno = last_revision_id = last_tree = None
313
 
    prev_tree = EmptyTree(branch.get_root_id())
314
 
 
315
 
    for revno, revision_id in which_revs:
316
 
        this_tree = branch.revision_tree(revision_id)
317
 
        this_revision = branch.get_revision(revision_id)
318
 
 
319
 
        if not last_revno:
320
 
            if revno == 1:
321
 
                last_tree = EmptyTree(branch.get_root_id())
322
 
            else:
323
 
                last_revno = revno - 1
324
 
                last_revision_id = branch.revision_history()[last_revno]
325
 
                last_tree = branch.revision_tree(last_revision_id)
326
 
 
327
 
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
328
 
 
329
 
        last_revno = revno
330
 
        last_revision = this_revision
331
 
        last_tree = this_tree
 
684
        revno = branch.revision_id_to_dotted_revno(rev_id)
 
685
    except errors.NoSuchRevision:
 
686
        # The revision must be outside of this branch
 
687
        return None
 
688
    else:
 
689
        return '.'.join(str(n) for n in revno)
 
690
 
 
691
 
 
692
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
 
693
    """Is start_rev_id an obvious ancestor of end_rev_id?"""
 
694
    if start_rev_id and end_rev_id:
 
695
        try:
 
696
            start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
 
697
            end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
 
698
        except errors.NoSuchRevision:
 
699
            # one or both is not in the branch; not obvious
 
700
            return False
 
701
        if len(start_dotted) == 1 and len(end_dotted) == 1:
 
702
            # both on mainline
 
703
            return start_dotted[0] <= end_dotted[0]
 
704
        elif (len(start_dotted) == 3 and len(end_dotted) == 3 and
 
705
            start_dotted[0:1] == end_dotted[0:1]):
 
706
            # both on same development line
 
707
            return start_dotted[2] <= end_dotted[2]
 
708
        else:
 
709
            # not obvious
 
710
            return False
 
711
    # if either start or end is not specified then we use either the first or
 
712
    # the last revision and *they* are obvious ancestors.
 
713
    return True
 
714
 
 
715
 
 
716
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
 
717
                           exclude_common_ancestry=False):
 
718
    """Calculate a sequence of revisions to view, newest to oldest.
 
719
 
 
720
    :param start_rev_id: the lower revision-id
 
721
    :param end_rev_id: the upper revision-id
 
722
    :param exclude_common_ancestry: Whether the start_rev_id should be part of
 
723
        the iterated revisions.
 
724
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
 
725
    :raises _StartNotLinearAncestor: if a start_rev_id is specified but
 
726
        is not found walking the left-hand history
 
727
    """
 
728
    br_revno, br_rev_id = branch.last_revision_info()
 
729
    repo = branch.repository
 
730
    graph = repo.get_graph()
 
731
    if start_rev_id is None and end_rev_id is None:
 
732
        cur_revno = br_revno
 
733
        for revision_id in graph.iter_lefthand_ancestry(br_rev_id,
 
734
            (_mod_revision.NULL_REVISION,)):
 
735
            yield revision_id, str(cur_revno), 0
 
736
            cur_revno -= 1
 
737
    else:
 
738
        if end_rev_id is None:
 
739
            end_rev_id = br_rev_id
 
740
        found_start = start_rev_id is None
 
741
        for revision_id in graph.iter_lefthand_ancestry(end_rev_id,
 
742
                (_mod_revision.NULL_REVISION,)):
 
743
            revno_str = _compute_revno_str(branch, revision_id)
 
744
            if not found_start and revision_id == start_rev_id:
 
745
                if not exclude_common_ancestry:
 
746
                    yield revision_id, revno_str, 0
 
747
                found_start = True
 
748
                break
 
749
            else:
 
750
                yield revision_id, revno_str, 0
 
751
        else:
 
752
            if not found_start:
 
753
                raise _StartNotLinearAncestor()
 
754
 
 
755
 
 
756
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
 
757
                          rebase_initial_depths=True,
 
758
                          exclude_common_ancestry=False):
 
759
    """Calculate revisions to view including merges, newest to oldest.
 
760
 
 
761
    :param branch: the branch
 
762
    :param start_rev_id: the lower revision-id
 
763
    :param end_rev_id: the upper revision-id
 
764
    :param rebase_initial_depth: should depths be rebased until a mainline
 
765
      revision is found?
 
766
    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
 
767
    """
 
768
    if exclude_common_ancestry:
 
769
        stop_rule = 'with-merges-without-common-ancestry'
 
770
    else:
 
771
        stop_rule = 'with-merges'
 
772
    view_revisions = branch.iter_merge_sorted_revisions(
 
773
        start_revision_id=end_rev_id, stop_revision_id=start_rev_id,
 
774
        stop_rule=stop_rule)
 
775
    if not rebase_initial_depths:
 
776
        for (rev_id, merge_depth, revno, end_of_merge
 
777
             ) in view_revisions:
 
778
            yield rev_id, '.'.join(map(str, revno)), merge_depth
 
779
    else:
 
780
        # We're following a development line starting at a merged revision.
 
781
        # We need to adjust depths down by the initial depth until we find
 
782
        # a depth less than it. Then we use that depth as the adjustment.
 
783
        # If and when we reach the mainline, depth adjustment ends.
 
784
        depth_adjustment = None
 
785
        for (rev_id, merge_depth, revno, end_of_merge
 
786
             ) in view_revisions:
 
787
            if depth_adjustment is None:
 
788
                depth_adjustment = merge_depth
 
789
            if depth_adjustment:
 
790
                if merge_depth < depth_adjustment:
 
791
                    # From now on we reduce the depth adjustement, this can be
 
792
                    # surprising for users. The alternative requires two passes
 
793
                    # which breaks the fast display of the first revision
 
794
                    # though.
 
795
                    depth_adjustment = merge_depth
 
796
                merge_depth -= depth_adjustment
 
797
            yield rev_id, '.'.join(map(str, revno)), merge_depth
 
798
 
 
799
 
 
800
def _rebase_merge_depth(view_revisions):
 
801
    """Adjust depths upwards so the top level is 0."""
 
802
    # If either the first or last revision have a merge_depth of 0, we're done
 
803
    if view_revisions and view_revisions[0][2] and view_revisions[-1][2]:
 
804
        min_depth = min([d for r,n,d in view_revisions])
 
805
        if min_depth != 0:
 
806
            view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
 
807
    return view_revisions
 
808
 
 
809
 
 
810
def make_log_rev_iterator(branch, view_revisions, generate_delta, search,
 
811
        file_ids=None, direction='reverse'):
 
812
    """Create a revision iterator for log.
 
813
 
 
814
    :param branch: The branch being logged.
 
815
    :param view_revisions: The revisions being viewed.
 
816
    :param generate_delta: Whether to generate a delta for each revision.
 
817
      Permitted values are None, 'full' and 'partial'.
 
818
    :param search: A user text search string.
 
819
    :param file_ids: If non empty, only revisions matching one or more of
 
820
      the file-ids are to be kept.
 
821
    :param direction: the direction in which view_revisions is sorted
 
822
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
 
823
        delta).
 
824
    """
 
825
    # Convert view_revisions into (view, None, None) groups to fit with
 
826
    # the standard interface here.
 
827
    if type(view_revisions) == list:
 
828
        # A single batch conversion is faster than many incremental ones.
 
829
        # As we have all the data, do a batch conversion.
 
830
        nones = [None] * len(view_revisions)
 
831
        log_rev_iterator = iter([zip(view_revisions, nones, nones)])
 
832
    else:
 
833
        def _convert():
 
834
            for view in view_revisions:
 
835
                yield (view, None, None)
 
836
        log_rev_iterator = iter([_convert()])
 
837
    for adapter in log_adapters:
 
838
        # It would be nicer if log adapters were first class objects
 
839
        # with custom parameters. This will do for now. IGC 20090127
 
840
        if adapter == _make_delta_filter:
 
841
            log_rev_iterator = adapter(branch, generate_delta,
 
842
                search, log_rev_iterator, file_ids, direction)
 
843
        else:
 
844
            log_rev_iterator = adapter(branch, generate_delta,
 
845
                search, log_rev_iterator)
 
846
    return log_rev_iterator
 
847
 
 
848
 
 
849
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
 
850
    """Create a filtered iterator of log_rev_iterator matching on a regex.
 
851
 
 
852
    :param branch: The branch being logged.
 
853
    :param generate_delta: Whether to generate a delta for each revision.
 
854
    :param match: A dictionary with properties as keys and lists of strings
 
855
        as values. To match, a revision may match any of the supplied strings
 
856
        within a single property but must match at least one string for each
 
857
        property.
 
858
    :param log_rev_iterator: An input iterator containing all revisions that
 
859
        could be displayed, in lists.
 
860
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
 
861
        delta).
 
862
    """
 
863
    if match is None:
 
864
        return log_rev_iterator
 
865
    searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
 
866
                for (k,v) in match.iteritems()]
 
867
    return _filter_re(searchRE, log_rev_iterator)
 
868
 
 
869
 
 
870
def _filter_re(searchRE, log_rev_iterator):
 
871
    for revs in log_rev_iterator:
 
872
        new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
 
873
        if new_revs:
 
874
            yield new_revs
 
875
 
 
876
def _match_filter(searchRE, rev):
 
877
    strings = {
 
878
               'message': (rev.message,),
 
879
               'committer': (rev.committer,),
 
880
               'author': (rev.get_apparent_authors()),
 
881
               'bugs': list(rev.iter_bugs())
 
882
               }
 
883
    strings[''] = [item for inner_list in strings.itervalues()
 
884
                   for item in inner_list]
 
885
    for (k,v) in searchRE:
 
886
        if k in strings and not _match_any_filter(strings[k], v):
 
887
            return False
 
888
    return True
 
889
 
 
890
def _match_any_filter(strings, res):
 
891
    return any([filter(None, map(re.search, strings)) for re in res])
 
892
 
 
893
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
 
894
    fileids=None, direction='reverse'):
 
895
    """Add revision deltas to a log iterator if needed.
 
896
 
 
897
    :param branch: The branch being logged.
 
898
    :param generate_delta: Whether to generate a delta for each revision.
 
899
      Permitted values are None, 'full' and 'partial'.
 
900
    :param search: A user text search string.
 
901
    :param log_rev_iterator: An input iterator containing all revisions that
 
902
        could be displayed, in lists.
 
903
    :param fileids: If non empty, only revisions matching one or more of
 
904
      the file-ids are to be kept.
 
905
    :param direction: the direction in which view_revisions is sorted
 
906
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
 
907
        delta).
 
908
    """
 
909
    if not generate_delta and not fileids:
 
910
        return log_rev_iterator
 
911
    return _generate_deltas(branch.repository, log_rev_iterator,
 
912
        generate_delta, fileids, direction)
 
913
 
 
914
 
 
915
def _generate_deltas(repository, log_rev_iterator, delta_type, fileids,
 
916
    direction):
 
917
    """Create deltas for each batch of revisions in log_rev_iterator.
 
918
 
 
919
    If we're only generating deltas for the sake of filtering against
 
920
    file-ids, we stop generating deltas once all file-ids reach the
 
921
    appropriate life-cycle point. If we're receiving data newest to
 
922
    oldest, then that life-cycle point is 'add', otherwise it's 'remove'.
 
923
    """
 
924
    check_fileids = fileids is not None and len(fileids) > 0
 
925
    if check_fileids:
 
926
        fileid_set = set(fileids)
 
927
        if direction == 'reverse':
 
928
            stop_on = 'add'
 
929
        else:
 
930
            stop_on = 'remove'
 
931
    else:
 
932
        fileid_set = None
 
933
    for revs in log_rev_iterator:
 
934
        # If we were matching against fileids and we've run out,
 
935
        # there's nothing left to do
 
936
        if check_fileids and not fileid_set:
 
937
            return
 
938
        revisions = [rev[1] for rev in revs]
 
939
        new_revs = []
 
940
        if delta_type == 'full' and not check_fileids:
 
941
            deltas = repository.get_deltas_for_revisions(revisions)
 
942
            for rev, delta in izip(revs, deltas):
 
943
                new_revs.append((rev[0], rev[1], delta))
 
944
        else:
 
945
            deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
 
946
            for rev, delta in izip(revs, deltas):
 
947
                if check_fileids:
 
948
                    if delta is None or not delta.has_changed():
 
949
                        continue
 
950
                    else:
 
951
                        _update_fileids(delta, fileid_set, stop_on)
 
952
                        if delta_type is None:
 
953
                            delta = None
 
954
                        elif delta_type == 'full':
 
955
                            # If the file matches all the time, rebuilding
 
956
                            # a full delta like this in addition to a partial
 
957
                            # one could be slow. However, it's likely that
 
958
                            # most revisions won't get this far, making it
 
959
                            # faster to filter on the partial deltas and
 
960
                            # build the occasional full delta than always
 
961
                            # building full deltas and filtering those.
 
962
                            rev_id = rev[0][0]
 
963
                            delta = repository.get_revision_delta(rev_id)
 
964
                new_revs.append((rev[0], rev[1], delta))
 
965
        yield new_revs
 
966
 
 
967
 
 
968
def _update_fileids(delta, fileids, stop_on):
 
969
    """Update the set of file-ids to search based on file lifecycle events.
 
970
 
 
971
    :param fileids: a set of fileids to update
 
972
    :param stop_on: either 'add' or 'remove' - take file-ids out of the
 
973
      fileids set once their add or remove entry is detected respectively
 
974
    """
 
975
    if stop_on == 'add':
 
976
        for item in delta.added:
 
977
            if item[1] in fileids:
 
978
                fileids.remove(item[1])
 
979
    elif stop_on == 'delete':
 
980
        for item in delta.removed:
 
981
            if item[1] in fileids:
 
982
                fileids.remove(item[1])
 
983
 
 
984
 
 
985
def _make_revision_objects(branch, generate_delta, search, log_rev_iterator):
 
986
    """Extract revision objects from the repository
 
987
 
 
988
    :param branch: The branch being logged.
 
989
    :param generate_delta: Whether to generate a delta for each revision.
 
990
    :param search: A user text search string.
 
991
    :param log_rev_iterator: An input iterator containing all revisions that
 
992
        could be displayed, in lists.
 
993
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
 
994
        delta).
 
995
    """
 
996
    repository = branch.repository
 
997
    for revs in log_rev_iterator:
 
998
        # r = revision_id, n = revno, d = merge depth
 
999
        revision_ids = [view[0] for view, _, _ in revs]
 
1000
        revisions = repository.get_revisions(revision_ids)
 
1001
        revs = [(rev[0], revision, rev[2]) for rev, revision in
 
1002
            izip(revs, revisions)]
 
1003
        yield revs
 
1004
 
 
1005
 
 
1006
def _make_batch_filter(branch, generate_delta, search, log_rev_iterator):
 
1007
    """Group up a single large batch into smaller ones.
 
1008
 
 
1009
    :param branch: The branch being logged.
 
1010
    :param generate_delta: Whether to generate a delta for each revision.
 
1011
    :param search: A user text search string.
 
1012
    :param log_rev_iterator: An input iterator containing all revisions that
 
1013
        could be displayed, in lists.
 
1014
    :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
 
1015
        delta).
 
1016
    """
 
1017
    num = 9
 
1018
    for batch in log_rev_iterator:
 
1019
        batch = iter(batch)
 
1020
        while True:
 
1021
            step = [detail for _, detail in zip(range(num), batch)]
 
1022
            if len(step) == 0:
 
1023
                break
 
1024
            yield step
 
1025
            num = min(int(num * 1.5), 200)
 
1026
 
 
1027
 
 
1028
def _get_revision_limits(branch, start_revision, end_revision):
 
1029
    """Get and check revision limits.
 
1030
 
 
1031
    :param  branch: The branch containing the revisions.
 
1032
 
 
1033
    :param  start_revision: The first revision to be logged.
 
1034
            For backwards compatibility this may be a mainline integer revno,
 
1035
            but for merge revision support a RevisionInfo is expected.
 
1036
 
 
1037
    :param  end_revision: The last revision to be logged.
 
1038
            For backwards compatibility this may be a mainline integer revno,
 
1039
            but for merge revision support a RevisionInfo is expected.
 
1040
 
 
1041
    :return: (start_rev_id, end_rev_id) tuple.
 
1042
    """
 
1043
    branch_revno, branch_rev_id = branch.last_revision_info()
 
1044
    start_rev_id = None
 
1045
    if start_revision is None:
 
1046
        start_revno = 1
 
1047
    else:
 
1048
        if isinstance(start_revision, revisionspec.RevisionInfo):
 
1049
            start_rev_id = start_revision.rev_id
 
1050
            start_revno = start_revision.revno or 1
 
1051
        else:
 
1052
            branch.check_real_revno(start_revision)
 
1053
            start_revno = start_revision
 
1054
            start_rev_id = branch.get_rev_id(start_revno)
 
1055
 
 
1056
    end_rev_id = None
 
1057
    if end_revision is None:
 
1058
        end_revno = branch_revno
 
1059
    else:
 
1060
        if isinstance(end_revision, revisionspec.RevisionInfo):
 
1061
            end_rev_id = end_revision.rev_id
 
1062
            end_revno = end_revision.revno or branch_revno
 
1063
        else:
 
1064
            branch.check_real_revno(end_revision)
 
1065
            end_revno = end_revision
 
1066
            end_rev_id = branch.get_rev_id(end_revno)
 
1067
 
 
1068
    if branch_revno != 0:
 
1069
        if (start_rev_id == _mod_revision.NULL_REVISION
 
1070
            or end_rev_id == _mod_revision.NULL_REVISION):
 
1071
            raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
 
1072
        if start_revno > end_revno:
 
1073
            raise errors.BzrCommandError(gettext("Start revision must be "
 
1074
                                         "older than the end revision."))
 
1075
    return (start_rev_id, end_rev_id)
 
1076
 
 
1077
 
 
1078
def _get_mainline_revs(branch, start_revision, end_revision):
 
1079
    """Get the mainline revisions from the branch.
 
1080
 
 
1081
    Generates the list of mainline revisions for the branch.
 
1082
 
 
1083
    :param  branch: The branch containing the revisions.
 
1084
 
 
1085
    :param  start_revision: The first revision to be logged.
 
1086
            For backwards compatibility this may be a mainline integer revno,
 
1087
            but for merge revision support a RevisionInfo is expected.
 
1088
 
 
1089
    :param  end_revision: The last revision to be logged.
 
1090
            For backwards compatibility this may be a mainline integer revno,
 
1091
            but for merge revision support a RevisionInfo is expected.
 
1092
 
 
1093
    :return: A (mainline_revs, rev_nos, start_rev_id, end_rev_id) tuple.
 
1094
    """
 
1095
    branch_revno, branch_last_revision = branch.last_revision_info()
 
1096
    if branch_revno == 0:
 
1097
        return None, None, None, None
 
1098
 
 
1099
    # For mainline generation, map start_revision and end_revision to
 
1100
    # mainline revnos. If the revision is not on the mainline choose the
 
1101
    # appropriate extreme of the mainline instead - the extra will be
 
1102
    # filtered later.
 
1103
    # Also map the revisions to rev_ids, to be used in the later filtering
 
1104
    # stage.
 
1105
    start_rev_id = None
 
1106
    if start_revision is None:
 
1107
        start_revno = 1
 
1108
    else:
 
1109
        if isinstance(start_revision, revisionspec.RevisionInfo):
 
1110
            start_rev_id = start_revision.rev_id
 
1111
            start_revno = start_revision.revno or 1
 
1112
        else:
 
1113
            branch.check_real_revno(start_revision)
 
1114
            start_revno = start_revision
 
1115
 
 
1116
    end_rev_id = None
 
1117
    if end_revision is None:
 
1118
        end_revno = branch_revno
 
1119
    else:
 
1120
        if isinstance(end_revision, revisionspec.RevisionInfo):
 
1121
            end_rev_id = end_revision.rev_id
 
1122
            end_revno = end_revision.revno or branch_revno
 
1123
        else:
 
1124
            branch.check_real_revno(end_revision)
 
1125
            end_revno = end_revision
 
1126
 
 
1127
    if ((start_rev_id == _mod_revision.NULL_REVISION)
 
1128
        or (end_rev_id == _mod_revision.NULL_REVISION)):
 
1129
        raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
 
1130
    if start_revno > end_revno:
 
1131
        raise errors.BzrCommandError(gettext("Start revision must be older "
 
1132
                                     "than the end revision."))
 
1133
 
 
1134
    if end_revno < start_revno:
 
1135
        return None, None, None, None
 
1136
    cur_revno = branch_revno
 
1137
    rev_nos = {}
 
1138
    mainline_revs = []
 
1139
    graph = branch.repository.get_graph()
 
1140
    for revision_id in graph.iter_lefthand_ancestry(
 
1141
            branch_last_revision, (_mod_revision.NULL_REVISION,)):
 
1142
        if cur_revno < start_revno:
 
1143
            # We have gone far enough, but we always add 1 more revision
 
1144
            rev_nos[revision_id] = cur_revno
 
1145
            mainline_revs.append(revision_id)
 
1146
            break
 
1147
        if cur_revno <= end_revno:
 
1148
            rev_nos[revision_id] = cur_revno
 
1149
            mainline_revs.append(revision_id)
 
1150
        cur_revno -= 1
 
1151
    else:
 
1152
        # We walked off the edge of all revisions, so we add a 'None' marker
 
1153
        mainline_revs.append(None)
 
1154
 
 
1155
    mainline_revs.reverse()
 
1156
 
 
1157
    # override the mainline to look like the revision history.
 
1158
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
 
1159
 
 
1160
 
 
1161
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
 
1162
    include_merges=True):
 
1163
    r"""Return the list of revision ids which touch a given file id.
 
1164
 
 
1165
    The function filters view_revisions and returns a subset.
 
1166
    This includes the revisions which directly change the file id,
 
1167
    and the revisions which merge these changes. So if the
 
1168
    revision graph is::
 
1169
 
 
1170
        A-.
 
1171
        |\ \
 
1172
        B C E
 
1173
        |/ /
 
1174
        D |
 
1175
        |\|
 
1176
        | F
 
1177
        |/
 
1178
        G
 
1179
 
 
1180
    And 'C' changes a file, then both C and D will be returned. F will not be
 
1181
    returned even though it brings the changes to C into the branch starting
 
1182
    with E. (Note that if we were using F as the tip instead of G, then we
 
1183
    would see C, D, F.)
 
1184
 
 
1185
    This will also be restricted based on a subset of the mainline.
 
1186
 
 
1187
    :param branch: The branch where we can get text revision information.
 
1188
 
 
1189
    :param file_id: Filter out revisions that do not touch file_id.
 
1190
 
 
1191
    :param view_revisions: A list of (revision_id, dotted_revno, merge_depth)
 
1192
        tuples. This is the list of revisions which will be filtered. It is
 
1193
        assumed that view_revisions is in merge_sort order (i.e. newest
 
1194
        revision first ).
 
1195
 
 
1196
    :param include_merges: include merge revisions in the result or not
 
1197
 
 
1198
    :return: A list of (revision_id, dotted_revno, merge_depth) tuples.
 
1199
    """
 
1200
    # Lookup all possible text keys to determine which ones actually modified
 
1201
    # the file.
 
1202
    graph = branch.repository.get_file_graph()
 
1203
    get_parent_map = graph.get_parent_map
 
1204
    text_keys = [(file_id, rev_id) for rev_id, revno, depth in view_revisions]
 
1205
    next_keys = None
 
1206
    # Looking up keys in batches of 1000 can cut the time in half, as well as
 
1207
    # memory consumption. GraphIndex *does* like to look for a few keys in
 
1208
    # parallel, it just doesn't like looking for *lots* of keys in parallel.
 
1209
    # TODO: This code needs to be re-evaluated periodically as we tune the
 
1210
    #       indexing layer. We might consider passing in hints as to the known
 
1211
    #       access pattern (sparse/clustered, high success rate/low success
 
1212
    #       rate). This particular access is clustered with a low success rate.
 
1213
    modified_text_revisions = set()
 
1214
    chunk_size = 1000
 
1215
    for start in xrange(0, len(text_keys), chunk_size):
 
1216
        next_keys = text_keys[start:start + chunk_size]
 
1217
        # Only keep the revision_id portion of the key
 
1218
        modified_text_revisions.update(
 
1219
            [k[1] for k in get_parent_map(next_keys)])
 
1220
    del text_keys, next_keys
 
1221
 
 
1222
    result = []
 
1223
    # Track what revisions will merge the current revision, replace entries
 
1224
    # with 'None' when they have been added to result
 
1225
    current_merge_stack = [None]
 
1226
    for info in view_revisions:
 
1227
        rev_id, revno, depth = info
 
1228
        if depth == len(current_merge_stack):
 
1229
            current_merge_stack.append(info)
 
1230
        else:
 
1231
            del current_merge_stack[depth + 1:]
 
1232
            current_merge_stack[-1] = info
 
1233
 
 
1234
        if rev_id in modified_text_revisions:
 
1235
            # This needs to be logged, along with the extra revisions
 
1236
            for idx in xrange(len(current_merge_stack)):
 
1237
                node = current_merge_stack[idx]
 
1238
                if node is not None:
 
1239
                    if include_merges or node[2] == 0:
 
1240
                        result.append(node)
 
1241
                        current_merge_stack[idx] = None
 
1242
    return result
 
1243
 
 
1244
 
 
1245
def reverse_by_depth(merge_sorted_revisions, _depth=0):
 
1246
    """Reverse revisions by depth.
 
1247
 
 
1248
    Revisions with a different depth are sorted as a group with the previous
 
1249
    revision of that depth.  There may be no topological justification for this,
 
1250
    but it looks much nicer.
 
1251
    """
 
1252
    # Add a fake revision at start so that we can always attach sub revisions
 
1253
    merge_sorted_revisions = [(None, None, _depth)] + merge_sorted_revisions
 
1254
    zd_revisions = []
 
1255
    for val in merge_sorted_revisions:
 
1256
        if val[2] == _depth:
 
1257
            # Each revision at the current depth becomes a chunk grouping all
 
1258
            # higher depth revisions.
 
1259
            zd_revisions.append([val])
 
1260
        else:
 
1261
            zd_revisions[-1].append(val)
 
1262
    for revisions in zd_revisions:
 
1263
        if len(revisions) > 1:
 
1264
            # We have higher depth revisions, let reverse them locally
 
1265
            revisions[1:] = reverse_by_depth(revisions[1:], _depth + 1)
 
1266
    zd_revisions.reverse()
 
1267
    result = []
 
1268
    for chunk in zd_revisions:
 
1269
        result.extend(chunk)
 
1270
    if _depth == 0:
 
1271
        # Top level call, get rid of the fake revisions that have been added
 
1272
        result = [r for r in result if r[0] is not None and r[1] is not None]
 
1273
    return result
 
1274
 
 
1275
 
 
1276
class LogRevision(object):
 
1277
    """A revision to be logged (by LogFormatter.log_revision).
 
1278
 
 
1279
    A simple wrapper for the attributes of a revision to be logged.
 
1280
    The attributes may or may not be populated, as determined by the
 
1281
    logging options and the log formatter capabilities.
 
1282
    """
 
1283
 
 
1284
    def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
 
1285
                 tags=None, diff=None, signature=None):
 
1286
        self.rev = rev
 
1287
        if revno is None:
 
1288
            self.revno = None
 
1289
        else:
 
1290
            self.revno = str(revno)
 
1291
        self.merge_depth = merge_depth
 
1292
        self.delta = delta
 
1293
        self.tags = tags
 
1294
        self.diff = diff
 
1295
        self.signature = signature
332
1296
 
333
1297
 
334
1298
class LogFormatter(object):
335
 
    """Abstract class to display log messages."""
336
 
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
1299
    """Abstract class to display log messages.
 
1300
 
 
1301
    At a minimum, a derived class must implement the log_revision method.
 
1302
 
 
1303
    If the LogFormatter needs to be informed of the beginning or end of
 
1304
    a log it should implement the begin_log and/or end_log hook methods.
 
1305
 
 
1306
    A LogFormatter should define the following supports_XXX flags
 
1307
    to indicate which LogRevision attributes it supports:
 
1308
 
 
1309
    - supports_delta must be True if this log formatter supports delta.
 
1310
      Otherwise the delta attribute may not be populated.  The 'delta_format'
 
1311
      attribute describes whether the 'short_status' format (1) or the long
 
1312
      one (2) should be used.
 
1313
 
 
1314
    - supports_merge_revisions must be True if this log formatter supports
 
1315
      merge revisions.  If not, then only mainline revisions will be passed
 
1316
      to the formatter.
 
1317
 
 
1318
    - preferred_levels is the number of levels this formatter defaults to.
 
1319
      The default value is zero meaning display all levels.
 
1320
      This value is only relevant if supports_merge_revisions is True.
 
1321
 
 
1322
    - supports_tags must be True if this log formatter supports tags.
 
1323
      Otherwise the tags attribute may not be populated.
 
1324
 
 
1325
    - supports_diff must be True if this log formatter supports diffs.
 
1326
      Otherwise the diff attribute may not be populated.
 
1327
 
 
1328
    - supports_signatures must be True if this log formatter supports GPG
 
1329
      signatures.
 
1330
 
 
1331
    Plugins can register functions to show custom revision properties using
 
1332
    the properties_handler_registry. The registered function
 
1333
    must respect the following interface description::
 
1334
 
 
1335
        def my_show_properties(properties_dict):
 
1336
            # code that returns a dict {'name':'value'} of the properties
 
1337
            # to be shown
 
1338
    """
 
1339
    preferred_levels = 0
 
1340
 
 
1341
    def __init__(self, to_file, show_ids=False, show_timezone='original',
 
1342
                 delta_format=None, levels=None, show_advice=False,
 
1343
                 to_exact_file=None, author_list_handler=None):
 
1344
        """Create a LogFormatter.
 
1345
 
 
1346
        :param to_file: the file to output to
 
1347
        :param to_exact_file: if set, gives an output stream to which
 
1348
             non-Unicode diffs are written.
 
1349
        :param show_ids: if True, revision-ids are to be displayed
 
1350
        :param show_timezone: the timezone to use
 
1351
        :param delta_format: the level of delta information to display
 
1352
          or None to leave it to the formatter to decide
 
1353
        :param levels: the number of levels to display; None or -1 to
 
1354
          let the log formatter decide.
 
1355
        :param show_advice: whether to show advice at the end of the
 
1356
          log or not
 
1357
        :param author_list_handler: callable generating a list of
 
1358
          authors to display for a given revision
 
1359
        """
337
1360
        self.to_file = to_file
 
1361
        # 'exact' stream used to show diff, it should print content 'as is'
 
1362
        # and should not try to decode/encode it to unicode to avoid bug #328007
 
1363
        if to_exact_file is not None:
 
1364
            self.to_exact_file = to_exact_file
 
1365
        else:
 
1366
            # XXX: somewhat hacky; this assumes it's a codec writer; it's better
 
1367
            # for code that expects to get diffs to pass in the exact file
 
1368
            # stream
 
1369
            self.to_exact_file = getattr(to_file, 'stream', to_file)
338
1370
        self.show_ids = show_ids
339
1371
        self.show_timezone = show_timezone
340
 
 
341
 
 
342
 
    def show(self, revno, rev, delta):
 
1372
        if delta_format is None:
 
1373
            # Ensures backward compatibility
 
1374
            delta_format = 2 # long format
 
1375
        self.delta_format = delta_format
 
1376
        self.levels = levels
 
1377
        self._show_advice = show_advice
 
1378
        self._merge_count = 0
 
1379
        self._author_list_handler = author_list_handler
 
1380
 
 
1381
    def get_levels(self):
 
1382
        """Get the number of levels to display or 0 for all."""
 
1383
        if getattr(self, 'supports_merge_revisions', False):
 
1384
            if self.levels is None or self.levels == -1:
 
1385
                self.levels = self.preferred_levels
 
1386
        else:
 
1387
            self.levels = 1
 
1388
        return self.levels
 
1389
 
 
1390
    def log_revision(self, revision):
 
1391
        """Log a revision.
 
1392
 
 
1393
        :param  revision:   The LogRevision to be logged.
 
1394
        """
343
1395
        raise NotImplementedError('not implemented in abstract base')
344
1396
 
345
 
    
 
1397
    def show_advice(self):
 
1398
        """Output user advice, if any, when the log is completed."""
 
1399
        if self._show_advice and self.levels == 1 and self._merge_count > 0:
 
1400
            advice_sep = self.get_advice_separator()
 
1401
            if advice_sep:
 
1402
                self.to_file.write(advice_sep)
 
1403
            self.to_file.write(
 
1404
                "Use --include-merged or -n0 to see merged revisions.\n")
 
1405
 
 
1406
    def get_advice_separator(self):
 
1407
        """Get the text separating the log from the closing advice."""
 
1408
        return ''
 
1409
 
 
1410
    def short_committer(self, rev):
 
1411
        name, address = config.parse_username(rev.committer)
 
1412
        if name:
 
1413
            return name
 
1414
        return address
 
1415
 
 
1416
    def short_author(self, rev):
 
1417
        return self.authors(rev, 'first', short=True, sep=', ')
 
1418
 
 
1419
    def authors(self, rev, who, short=False, sep=None):
 
1420
        """Generate list of authors, taking --authors option into account.
 
1421
 
 
1422
        The caller has to specify the name of a author list handler,
 
1423
        as provided by the author list registry, using the ``who``
 
1424
        argument.  That name only sets a default, though: when the
 
1425
        user selected a different author list generation using the
 
1426
        ``--authors`` command line switch, as represented by the
 
1427
        ``author_list_handler`` constructor argument, that value takes
 
1428
        precedence.
 
1429
 
 
1430
        :param rev: The revision for which to generate the list of authors.
 
1431
        :param who: Name of the default handler.
 
1432
        :param short: Whether to shorten names to either name or address.
 
1433
        :param sep: What separator to use for automatic concatenation.
 
1434
        """
 
1435
        if self._author_list_handler is not None:
 
1436
            # The user did specify --authors, which overrides the default
 
1437
            author_list_handler = self._author_list_handler
 
1438
        else:
 
1439
            # The user didn't specify --authors, so we use the caller's default
 
1440
            author_list_handler = author_list_registry.get(who)
 
1441
        names = author_list_handler(rev)
 
1442
        if short:
 
1443
            for i in range(len(names)):
 
1444
                name, address = config.parse_username(names[i])
 
1445
                if name:
 
1446
                    names[i] = name
 
1447
                else:
 
1448
                    names[i] = address
 
1449
        if sep is not None:
 
1450
            names = sep.join(names)
 
1451
        return names
 
1452
 
 
1453
    def merge_marker(self, revision):
 
1454
        """Get the merge marker to include in the output or '' if none."""
 
1455
        if len(revision.rev.parent_ids) > 1:
 
1456
            self._merge_count += 1
 
1457
            return ' [merge]'
 
1458
        else:
 
1459
            return ''
 
1460
 
 
1461
    def show_properties(self, revision, indent):
 
1462
        """Displays the custom properties returned by each registered handler.
 
1463
 
 
1464
        If a registered handler raises an error it is propagated.
 
1465
        """
 
1466
        for line in self.custom_properties(revision):
 
1467
            self.to_file.write("%s%s\n" % (indent, line))
 
1468
 
 
1469
    def custom_properties(self, revision):
 
1470
        """Format the custom properties returned by each registered handler.
 
1471
 
 
1472
        If a registered handler raises an error it is propagated.
 
1473
 
 
1474
        :return: a list of formatted lines (excluding trailing newlines)
 
1475
        """
 
1476
        lines = self._foreign_info_properties(revision)
 
1477
        for key, handler in properties_handler_registry.iteritems():
 
1478
            lines.extend(self._format_properties(handler(revision)))
 
1479
        return lines
 
1480
 
 
1481
    def _foreign_info_properties(self, rev):
 
1482
        """Custom log displayer for foreign revision identifiers.
 
1483
 
 
1484
        :param rev: Revision object.
 
1485
        """
 
1486
        # Revision comes directly from a foreign repository
 
1487
        if isinstance(rev, foreign.ForeignRevision):
 
1488
            return self._format_properties(
 
1489
                rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
 
1490
 
 
1491
        # Imported foreign revision revision ids always contain :
 
1492
        if not ":" in rev.revision_id:
 
1493
            return []
 
1494
 
 
1495
        # Revision was once imported from a foreign repository
 
1496
        try:
 
1497
            foreign_revid, mapping = \
 
1498
                foreign.foreign_vcs_registry.parse_revision_id(rev.revision_id)
 
1499
        except errors.InvalidRevisionId:
 
1500
            return []
 
1501
 
 
1502
        return self._format_properties(
 
1503
            mapping.vcs.show_foreign_revid(foreign_revid))
 
1504
 
 
1505
    def _format_properties(self, properties):
 
1506
        lines = []
 
1507
        for key, value in properties.items():
 
1508
            lines.append(key + ': ' + value)
 
1509
        return lines
 
1510
 
 
1511
    def show_diff(self, to_file, diff, indent):
 
1512
        for l in diff.rstrip().split('\n'):
 
1513
            to_file.write(indent + '%s\n' % (l,))
 
1514
 
 
1515
 
 
1516
# Separator between revisions in long format
 
1517
_LONG_SEP = '-' * 60
 
1518
 
 
1519
 
346
1520
class LongLogFormatter(LogFormatter):
347
 
    def show(self, revno, rev, delta):
348
 
        from osutils import format_date
349
 
 
350
 
        to_file = self.to_file
351
 
 
352
 
        print >>to_file,  '-' * 60
353
 
        print >>to_file,  'revno:', revno
354
 
        if self.show_ids:
355
 
            print >>to_file,  'revision-id:', rev.revision_id
356
 
 
357
 
            for parent_id in rev.parent_ids:
358
 
                print >>to_file, 'parent:', parent_id
359
 
            
360
 
        print >>to_file,  'committer:', rev.committer
361
 
 
362
 
        date_str = format_date(rev.timestamp,
363
 
                               rev.timezone or 0,
364
 
                               self.show_timezone)
365
 
        print >>to_file,  'timestamp: %s' % date_str
366
 
 
367
 
        print >>to_file,  'message:'
368
 
        if not rev.message:
369
 
            print >>to_file,  '  (no message)'
370
 
        else:
371
 
            for l in rev.message.split('\n'):
372
 
                print >>to_file,  '  ' + l
373
 
 
374
 
        if delta != None:
375
 
            delta.show(to_file, self.show_ids)
376
 
 
377
 
    def show_merge(self, rev):
378
 
        from osutils import format_date
379
 
 
380
 
        to_file = self.to_file
381
 
 
382
 
        indent = '    '
383
 
 
384
 
        print >>to_file,  indent+'-' * 60
385
 
        print >>to_file,  indent+'merged:', rev.revision_id
386
 
        if self.show_ids:
387
 
            for parent_id in rev.parent_ids:
388
 
                print >>to_file, indent+'parent:', parent_id
389
 
            
390
 
        print >>to_file,  indent+'committer:', rev.committer
391
 
 
392
 
        date_str = format_date(rev.timestamp,
393
 
                               rev.timezone or 0,
394
 
                               self.show_timezone)
395
 
        print >>to_file,  indent+'timestamp: %s' % date_str
396
 
 
397
 
        print >>to_file,  indent+'message:'
398
 
        if not rev.message:
399
 
            print >>to_file,  indent+'  (no message)'
400
 
        else:
401
 
            for l in rev.message.split('\n'):
402
 
                print >>to_file,  indent+'  ' + l
 
1521
 
 
1522
    supports_merge_revisions = True
 
1523
    preferred_levels = 1
 
1524
    supports_delta = True
 
1525
    supports_tags = True
 
1526
    supports_diff = True
 
1527
    supports_signatures = True
 
1528
 
 
1529
    def __init__(self, *args, **kwargs):
 
1530
        super(LongLogFormatter, self).__init__(*args, **kwargs)
 
1531
        if self.show_timezone == 'original':
 
1532
            self.date_string = self._date_string_original_timezone
 
1533
        else:
 
1534
            self.date_string = self._date_string_with_timezone
 
1535
 
 
1536
    def _date_string_with_timezone(self, rev):
 
1537
        return format_date(rev.timestamp, rev.timezone or 0,
 
1538
                           self.show_timezone)
 
1539
 
 
1540
    def _date_string_original_timezone(self, rev):
 
1541
        return format_date_with_offset_in_original_timezone(rev.timestamp,
 
1542
            rev.timezone or 0)
 
1543
 
 
1544
    def log_revision(self, revision):
 
1545
        """Log a revision, either merged or not."""
 
1546
        indent = '    ' * revision.merge_depth
 
1547
        lines = [_LONG_SEP]
 
1548
        if revision.revno is not None:
 
1549
            lines.append('revno: %s%s' % (revision.revno,
 
1550
                self.merge_marker(revision)))
 
1551
        if revision.tags:
 
1552
            lines.append('tags: %s' % (', '.join(revision.tags)))
 
1553
        if self.show_ids or revision.revno is None:
 
1554
            lines.append('revision-id: %s' % (revision.rev.revision_id,))
 
1555
        if self.show_ids:
 
1556
            for parent_id in revision.rev.parent_ids:
 
1557
                lines.append('parent: %s' % (parent_id,))
 
1558
        lines.extend(self.custom_properties(revision.rev))
 
1559
 
 
1560
        committer = revision.rev.committer
 
1561
        authors = self.authors(revision.rev, 'all')
 
1562
        if authors != [committer]:
 
1563
            lines.append('author: %s' % (", ".join(authors),))
 
1564
        lines.append('committer: %s' % (committer,))
 
1565
 
 
1566
        branch_nick = revision.rev.properties.get('branch-nick', None)
 
1567
        if branch_nick is not None:
 
1568
            lines.append('branch nick: %s' % (branch_nick,))
 
1569
 
 
1570
        lines.append('timestamp: %s' % (self.date_string(revision.rev),))
 
1571
 
 
1572
        if revision.signature is not None:
 
1573
            lines.append('signature: ' + revision.signature)
 
1574
 
 
1575
        lines.append('message:')
 
1576
        if not revision.rev.message:
 
1577
            lines.append('  (no message)')
 
1578
        else:
 
1579
            message = revision.rev.message.rstrip('\r\n')
 
1580
            for l in message.split('\n'):
 
1581
                lines.append('  %s' % (l,))
 
1582
 
 
1583
        # Dump the output, appending the delta and diff if requested
 
1584
        to_file = self.to_file
 
1585
        to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
 
1586
        if revision.delta is not None:
 
1587
            # Use the standard status output to display changes
 
1588
            from bzrlib.delta import report_delta
 
1589
            report_delta(to_file, revision.delta, short_status=False,
 
1590
                         show_ids=self.show_ids, indent=indent)
 
1591
        if revision.diff is not None:
 
1592
            to_file.write(indent + 'diff:\n')
 
1593
            to_file.flush()
 
1594
            # Note: we explicitly don't indent the diff (relative to the
 
1595
            # revision information) so that the output can be fed to patch -p0
 
1596
            self.show_diff(self.to_exact_file, revision.diff, indent)
 
1597
            self.to_exact_file.flush()
 
1598
 
 
1599
    def get_advice_separator(self):
 
1600
        """Get the text separating the log from the closing advice."""
 
1601
        return '-' * 60 + '\n'
403
1602
 
404
1603
 
405
1604
class ShortLogFormatter(LogFormatter):
406
 
    def show(self, revno, rev, delta):
407
 
        from bzrlib.osutils import format_date
 
1605
 
 
1606
    supports_merge_revisions = True
 
1607
    preferred_levels = 1
 
1608
    supports_delta = True
 
1609
    supports_tags = True
 
1610
    supports_diff = True
 
1611
 
 
1612
    def __init__(self, *args, **kwargs):
 
1613
        super(ShortLogFormatter, self).__init__(*args, **kwargs)
 
1614
        self.revno_width_by_depth = {}
 
1615
 
 
1616
    def log_revision(self, revision):
 
1617
        # We need two indents: one per depth and one for the information
 
1618
        # relative to that indent. Most mainline revnos are 5 chars or
 
1619
        # less while dotted revnos are typically 11 chars or less. Once
 
1620
        # calculated, we need to remember the offset for a given depth
 
1621
        # as we might be starting from a dotted revno in the first column
 
1622
        # and we want subsequent mainline revisions to line up.
 
1623
        depth = revision.merge_depth
 
1624
        indent = '    ' * depth
 
1625
        revno_width = self.revno_width_by_depth.get(depth)
 
1626
        if revno_width is None:
 
1627
            if revision.revno is None or revision.revno.find('.') == -1:
 
1628
                # mainline revno, e.g. 12345
 
1629
                revno_width = 5
 
1630
            else:
 
1631
                # dotted revno, e.g. 12345.10.55
 
1632
                revno_width = 11
 
1633
            self.revno_width_by_depth[depth] = revno_width
 
1634
        offset = ' ' * (revno_width + 1)
408
1635
 
409
1636
        to_file = self.to_file
410
 
        date_str = format_date(rev.timestamp, rev.timezone or 0,
411
 
                            self.show_timezone)
412
 
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
413
 
                format_date(rev.timestamp, rev.timezone or 0,
414
 
                            self.show_timezone))
415
 
        if self.show_ids:
416
 
            print >>to_file,  '      revision-id:', rev.revision_id
417
 
        if not rev.message:
418
 
            print >>to_file,  '      (no message)'
 
1637
        tags = ''
 
1638
        if revision.tags:
 
1639
            tags = ' {%s}' % (', '.join(revision.tags))
 
1640
        to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
 
1641
                revision.revno or "", self.short_author(revision.rev),
 
1642
                format_date(revision.rev.timestamp,
 
1643
                            revision.rev.timezone or 0,
 
1644
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
1645
                            show_offset=False),
 
1646
                tags, self.merge_marker(revision)))
 
1647
        self.show_properties(revision.rev, indent+offset)
 
1648
        if self.show_ids or revision.revno is None:
 
1649
            to_file.write(indent + offset + 'revision-id:%s\n'
 
1650
                          % (revision.rev.revision_id,))
 
1651
        if not revision.rev.message:
 
1652
            to_file.write(indent + offset + '(no message)\n')
419
1653
        else:
420
 
            for l in rev.message.split('\n'):
421
 
                print >>to_file,  '      ' + l
422
 
 
423
 
        # TODO: Why not show the modified files in a shorter form as
424
 
        # well? rewrap them single lines of appropriate length
425
 
        if delta != None:
426
 
            delta.show(to_file, self.show_ids)
427
 
        print
 
1654
            message = revision.rev.message.rstrip('\r\n')
 
1655
            for l in message.split('\n'):
 
1656
                to_file.write(indent + offset + '%s\n' % (l,))
 
1657
 
 
1658
        if revision.delta is not None:
 
1659
            # Use the standard status output to display changes
 
1660
            from bzrlib.delta import report_delta
 
1661
            report_delta(to_file, revision.delta,
 
1662
                         short_status=self.delta_format==1,
 
1663
                         show_ids=self.show_ids, indent=indent + offset)
 
1664
        if revision.diff is not None:
 
1665
            self.show_diff(self.to_exact_file, revision.diff, '      ')
 
1666
        to_file.write('\n')
 
1667
 
428
1668
 
429
1669
class LineLogFormatter(LogFormatter):
 
1670
 
 
1671
    supports_merge_revisions = True
 
1672
    preferred_levels = 1
 
1673
    supports_tags = True
 
1674
 
 
1675
    def __init__(self, *args, **kwargs):
 
1676
        super(LineLogFormatter, self).__init__(*args, **kwargs)
 
1677
        width = terminal_width()
 
1678
        if width is not None:
 
1679
            # we need one extra space for terminals that wrap on last char
 
1680
            width = width - 1
 
1681
        self._max_chars = width
 
1682
 
430
1683
    def truncate(self, str, max_len):
431
 
        if len(str) <= max_len:
 
1684
        if max_len is None or len(str) <= max_len:
432
1685
            return str
433
 
        return str[:max_len-3]+'...'
 
1686
        return str[:max_len-3] + '...'
434
1687
 
435
1688
    def date_string(self, rev):
436
 
        from bzrlib.osutils import format_date
437
 
        return format_date(rev.timestamp, rev.timezone or 0, 
 
1689
        return format_date(rev.timestamp, rev.timezone or 0,
438
1690
                           self.show_timezone, date_fmt="%Y-%m-%d",
439
1691
                           show_offset=False)
440
1692
 
444
1696
        else:
445
1697
            return rev.message
446
1698
 
447
 
    def short_committer(self, rev):
448
 
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
449
 
    
450
 
    def show(self, revno, rev, delta):
451
 
        print >> self.to_file, self.log_string(rev, 79) 
452
 
 
453
 
    def log_string(self, rev, max_chars):
454
 
        out = [self.truncate(self.short_committer(rev), 20)]
 
1699
    def log_revision(self, revision):
 
1700
        indent = '  ' * revision.merge_depth
 
1701
        self.to_file.write(self.log_string(revision.revno, revision.rev,
 
1702
            self._max_chars, revision.tags, indent))
 
1703
        self.to_file.write('\n')
 
1704
 
 
1705
    def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
 
1706
        """Format log info into one string. Truncate tail of string
 
1707
 
 
1708
        :param revno:      revision number or None.
 
1709
                           Revision numbers counts from 1.
 
1710
        :param rev:        revision object
 
1711
        :param max_chars:  maximum length of resulting string
 
1712
        :param tags:       list of tags or None
 
1713
        :param prefix:     string to prefix each line
 
1714
        :return:           formatted truncated string
 
1715
        """
 
1716
        out = []
 
1717
        if revno:
 
1718
            # show revno only when is not None
 
1719
            out.append("%s:" % revno)
 
1720
        if max_chars is not None:
 
1721
            out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
 
1722
        else:
 
1723
            out.append(self.short_author(rev))
455
1724
        out.append(self.date_string(rev))
456
 
        out.append(self.message(rev).replace('\n', ' '))
457
 
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
1725
        if len(rev.parent_ids) > 1:
 
1726
            out.append('[merge]')
 
1727
        if tags:
 
1728
            tag_str = '{%s}' % (', '.join(tags))
 
1729
            out.append(tag_str)
 
1730
        out.append(rev.get_summary())
 
1731
        return self.truncate(prefix + " ".join(out).rstrip('\n'), max_chars)
 
1732
 
 
1733
 
 
1734
class GnuChangelogLogFormatter(LogFormatter):
 
1735
 
 
1736
    supports_merge_revisions = True
 
1737
    supports_delta = True
 
1738
 
 
1739
    def log_revision(self, revision):
 
1740
        """Log a revision, either merged or not."""
 
1741
        to_file = self.to_file
 
1742
 
 
1743
        date_str = format_date(revision.rev.timestamp,
 
1744
                               revision.rev.timezone or 0,
 
1745
                               self.show_timezone,
 
1746
                               date_fmt='%Y-%m-%d',
 
1747
                               show_offset=False)
 
1748
        committer_str = self.authors(revision.rev, 'first', sep=', ')
 
1749
        committer_str = committer_str.replace(' <', '  <')
 
1750
        to_file.write('%s  %s\n\n' % (date_str,committer_str))
 
1751
 
 
1752
        if revision.delta is not None and revision.delta.has_changed():
 
1753
            for c in revision.delta.added + revision.delta.removed + revision.delta.modified:
 
1754
                path, = c[:1]
 
1755
                to_file.write('\t* %s:\n' % (path,))
 
1756
            for c in revision.delta.renamed:
 
1757
                oldpath,newpath = c[:2]
 
1758
                # For renamed files, show both the old and the new path
 
1759
                to_file.write('\t* %s:\n\t* %s:\n' % (oldpath,newpath))
 
1760
            to_file.write('\n')
 
1761
 
 
1762
        if not revision.rev.message:
 
1763
            to_file.write('\tNo commit message\n')
 
1764
        else:
 
1765
            message = revision.rev.message.rstrip('\r\n')
 
1766
            for l in message.split('\n'):
 
1767
                to_file.write('\t%s\n' % (l.lstrip(),))
 
1768
            to_file.write('\n')
 
1769
 
458
1770
 
459
1771
def line_log(rev, max_chars):
460
1772
    lf = LineLogFormatter(None)
461
 
    return lf.log_string(rev, max_chars)
462
 
 
463
 
FORMATTERS = {'long': LongLogFormatter,
464
 
              'short': ShortLogFormatter,
465
 
              'line': LineLogFormatter,
466
 
              }
 
1773
    return lf.log_string(None, rev, max_chars)
 
1774
 
 
1775
 
 
1776
class LogFormatterRegistry(registry.Registry):
 
1777
    """Registry for log formatters"""
 
1778
 
 
1779
    def make_formatter(self, name, *args, **kwargs):
 
1780
        """Construct a formatter from arguments.
 
1781
 
 
1782
        :param name: Name of the formatter to construct.  'short', 'long' and
 
1783
            'line' are built-in.
 
1784
        """
 
1785
        return self.get(name)(*args, **kwargs)
 
1786
 
 
1787
    def get_default(self, branch):
 
1788
        c = branch.get_config_stack()
 
1789
        return self.get(c.get('log_format'))
 
1790
 
 
1791
 
 
1792
log_formatter_registry = LogFormatterRegistry()
 
1793
 
 
1794
 
 
1795
log_formatter_registry.register('short', ShortLogFormatter,
 
1796
                                'Moderately short log format.')
 
1797
log_formatter_registry.register('long', LongLogFormatter,
 
1798
                                'Detailed log format.')
 
1799
log_formatter_registry.register('line', LineLogFormatter,
 
1800
                                'Log format with one line per revision.')
 
1801
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
 
1802
                                'Format used by GNU ChangeLog files.')
 
1803
 
 
1804
 
 
1805
def register_formatter(name, formatter):
 
1806
    log_formatter_registry.register(name, formatter)
467
1807
 
468
1808
 
469
1809
def log_formatter(name, *args, **kwargs):
472
1812
    name -- Name of the formatter to construct; currently 'long', 'short' and
473
1813
        'line' are supported.
474
1814
    """
475
 
    from bzrlib.errors import BzrCommandError
476
 
    try:
477
 
        return FORMATTERS[name](*args, **kwargs)
 
1815
    try:
 
1816
        return log_formatter_registry.make_formatter(name, *args, **kwargs)
 
1817
    except KeyError:
 
1818
        raise errors.BzrCommandError(gettext("unknown log formatter: %r") % name)
 
1819
 
 
1820
 
 
1821
def author_list_all(rev):
 
1822
    return rev.get_apparent_authors()[:]
 
1823
 
 
1824
 
 
1825
def author_list_first(rev):
 
1826
    lst = rev.get_apparent_authors()
 
1827
    try:
 
1828
        return [lst[0]]
478
1829
    except IndexError:
479
 
        raise BzrCommandError("unknown log formatter: %r" % name)
480
 
 
481
 
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
482
 
    # deprecated; for compatability
483
 
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
484
 
    lf.show(revno, rev, delta)
 
1830
        return []
 
1831
 
 
1832
 
 
1833
def author_list_committer(rev):
 
1834
    return [rev.committer]
 
1835
 
 
1836
 
 
1837
author_list_registry = registry.Registry()
 
1838
 
 
1839
author_list_registry.register('all', author_list_all,
 
1840
                              'All authors')
 
1841
 
 
1842
author_list_registry.register('first', author_list_first,
 
1843
                              'The first author')
 
1844
 
 
1845
author_list_registry.register('committer', author_list_committer,
 
1846
                              'The committer')
 
1847
 
 
1848
 
 
1849
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
 
1850
                           log_format='long'):
 
1851
    """Show the change in revision history comparing the old revision history to the new one.
 
1852
 
 
1853
    :param branch: The branch where the revisions exist
 
1854
    :param old_rh: The old revision history
 
1855
    :param new_rh: The new revision history
 
1856
    :param to_file: A file to write the results to. If None, stdout will be used
 
1857
    """
 
1858
    if to_file is None:
 
1859
        to_file = codecs.getwriter(get_terminal_encoding())(sys.stdout,
 
1860
            errors='replace')
 
1861
    lf = log_formatter(log_format,
 
1862
                       show_ids=False,
 
1863
                       to_file=to_file,
 
1864
                       show_timezone='original')
 
1865
 
 
1866
    # This is the first index which is different between
 
1867
    # old and new
 
1868
    base_idx = None
 
1869
    for i in xrange(max(len(new_rh),
 
1870
                        len(old_rh))):
 
1871
        if (len(new_rh) <= i
 
1872
            or len(old_rh) <= i
 
1873
            or new_rh[i] != old_rh[i]):
 
1874
            base_idx = i
 
1875
            break
 
1876
 
 
1877
    if base_idx is None:
 
1878
        to_file.write('Nothing seems to have changed\n')
 
1879
        return
 
1880
    ## TODO: It might be nice to do something like show_log
 
1881
    ##       and show the merged entries. But since this is the
 
1882
    ##       removed revisions, it shouldn't be as important
 
1883
    if base_idx < len(old_rh):
 
1884
        to_file.write('*'*60)
 
1885
        to_file.write('\nRemoved Revisions:\n')
 
1886
        for i in range(base_idx, len(old_rh)):
 
1887
            rev = branch.repository.get_revision(old_rh[i])
 
1888
            lr = LogRevision(rev, i+1, 0, None)
 
1889
            lf.log_revision(lr)
 
1890
        to_file.write('*'*60)
 
1891
        to_file.write('\n\n')
 
1892
    if base_idx < len(new_rh):
 
1893
        to_file.write('Added Revisions:\n')
 
1894
        show_log(branch,
 
1895
                 lf,
 
1896
                 None,
 
1897
                 verbose=False,
 
1898
                 direction='forward',
 
1899
                 start_revision=base_idx+1,
 
1900
                 end_revision=len(new_rh),
 
1901
                 search=None)
 
1902
 
 
1903
 
 
1904
def get_history_change(old_revision_id, new_revision_id, repository):
 
1905
    """Calculate the uncommon lefthand history between two revisions.
 
1906
 
 
1907
    :param old_revision_id: The original revision id.
 
1908
    :param new_revision_id: The new revision id.
 
1909
    :param repository: The repository to use for the calculation.
 
1910
 
 
1911
    return old_history, new_history
 
1912
    """
 
1913
    old_history = []
 
1914
    old_revisions = set()
 
1915
    new_history = []
 
1916
    new_revisions = set()
 
1917
    graph = repository.get_graph()
 
1918
    new_iter = graph.iter_lefthand_ancestry(new_revision_id)
 
1919
    old_iter = graph.iter_lefthand_ancestry(old_revision_id)
 
1920
    stop_revision = None
 
1921
    do_old = True
 
1922
    do_new = True
 
1923
    while do_new or do_old:
 
1924
        if do_new:
 
1925
            try:
 
1926
                new_revision = new_iter.next()
 
1927
            except StopIteration:
 
1928
                do_new = False
 
1929
            else:
 
1930
                new_history.append(new_revision)
 
1931
                new_revisions.add(new_revision)
 
1932
                if new_revision in old_revisions:
 
1933
                    stop_revision = new_revision
 
1934
                    break
 
1935
        if do_old:
 
1936
            try:
 
1937
                old_revision = old_iter.next()
 
1938
            except StopIteration:
 
1939
                do_old = False
 
1940
            else:
 
1941
                old_history.append(old_revision)
 
1942
                old_revisions.add(old_revision)
 
1943
                if old_revision in new_revisions:
 
1944
                    stop_revision = old_revision
 
1945
                    break
 
1946
    new_history.reverse()
 
1947
    old_history.reverse()
 
1948
    if stop_revision is not None:
 
1949
        new_history = new_history[new_history.index(stop_revision) + 1:]
 
1950
        old_history = old_history[old_history.index(stop_revision) + 1:]
 
1951
    return old_history, new_history
 
1952
 
 
1953
 
 
1954
def show_branch_change(branch, output, old_revno, old_revision_id):
 
1955
    """Show the changes made to a branch.
 
1956
 
 
1957
    :param branch: The branch to show changes about.
 
1958
    :param output: A file-like object to write changes to.
 
1959
    :param old_revno: The revno of the old tip.
 
1960
    :param old_revision_id: The revision_id of the old tip.
 
1961
    """
 
1962
    new_revno, new_revision_id = branch.last_revision_info()
 
1963
    old_history, new_history = get_history_change(old_revision_id,
 
1964
                                                  new_revision_id,
 
1965
                                                  branch.repository)
 
1966
    if old_history == [] and new_history == []:
 
1967
        output.write('Nothing seems to have changed\n')
 
1968
        return
 
1969
 
 
1970
    log_format = log_formatter_registry.get_default(branch)
 
1971
    lf = log_format(show_ids=False, to_file=output, show_timezone='original')
 
1972
    if old_history != []:
 
1973
        output.write('*'*60)
 
1974
        output.write('\nRemoved Revisions:\n')
 
1975
        show_flat_log(branch.repository, old_history, old_revno, lf)
 
1976
        output.write('*'*60)
 
1977
        output.write('\n\n')
 
1978
    if new_history != []:
 
1979
        output.write('Added Revisions:\n')
 
1980
        start_revno = new_revno - len(new_history) + 1
 
1981
        show_log(branch, lf, None, verbose=False, direction='forward',
 
1982
                 start_revision=start_revno,)
 
1983
 
 
1984
 
 
1985
def show_flat_log(repository, history, last_revno, lf):
 
1986
    """Show a simple log of the specified history.
 
1987
 
 
1988
    :param repository: The repository to retrieve revisions from.
 
1989
    :param history: A list of revision_ids indicating the lefthand history.
 
1990
    :param last_revno: The revno of the last revision_id in the history.
 
1991
    :param lf: The log formatter to use.
 
1992
    """
 
1993
    start_revno = last_revno - len(history) + 1
 
1994
    revisions = repository.get_revisions(history)
 
1995
    for i, rev in enumerate(revisions):
 
1996
        lr = LogRevision(rev, i + last_revno, 0, None)
 
1997
        lf.log_revision(lr)
 
1998
 
 
1999
 
 
2000
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
 
2001
    """Find file-ids and kinds given a list of files and a revision range.
 
2002
 
 
2003
    We search for files at the end of the range. If not found there,
 
2004
    we try the start of the range.
 
2005
 
 
2006
    :param revisionspec_list: revision range as parsed on the command line
 
2007
    :param file_list: the list of paths given on the command line;
 
2008
      the first of these can be a branch location or a file path,
 
2009
      the remainder must be file paths
 
2010
    :param add_cleanup: When the branch returned is read locked,
 
2011
      an unlock call will be queued to the cleanup.
 
2012
    :return: (branch, info_list, start_rev_info, end_rev_info) where
 
2013
      info_list is a list of (relative_path, file_id, kind) tuples where
 
2014
      kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
 
2015
      branch will be read-locked.
 
2016
    """
 
2017
    from bzrlib.builtins import _get_revision_range
 
2018
    tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
 
2019
        file_list[0])
 
2020
    add_cleanup(b.lock_read().unlock)
 
2021
    # XXX: It's damn messy converting a list of paths to relative paths when
 
2022
    # those paths might be deleted ones, they might be on a case-insensitive
 
2023
    # filesystem and/or they might be in silly locations (like another branch).
 
2024
    # For example, what should "log bzr://branch/dir/file1 file2" do? (Is
 
2025
    # file2 implicitly in the same dir as file1 or should its directory be
 
2026
    # taken from the current tree somehow?) For now, this solves the common
 
2027
    # case of running log in a nested directory, assuming paths beyond the
 
2028
    # first one haven't been deleted ...
 
2029
    if tree:
 
2030
        relpaths = [path] + tree.safe_relpath_files(file_list[1:])
 
2031
    else:
 
2032
        relpaths = [path] + file_list[1:]
 
2033
    info_list = []
 
2034
    start_rev_info, end_rev_info = _get_revision_range(revisionspec_list, b,
 
2035
        "log")
 
2036
    if relpaths in ([], [u'']):
 
2037
        return b, [], start_rev_info, end_rev_info
 
2038
    if start_rev_info is None and end_rev_info is None:
 
2039
        if tree is None:
 
2040
            tree = b.basis_tree()
 
2041
        tree1 = None
 
2042
        for fp in relpaths:
 
2043
            file_id = tree.path2id(fp)
 
2044
            kind = _get_kind_for_file_id(tree, file_id)
 
2045
            if file_id is None:
 
2046
                # go back to when time began
 
2047
                if tree1 is None:
 
2048
                    try:
 
2049
                        rev1 = b.get_rev_id(1)
 
2050
                    except errors.NoSuchRevision:
 
2051
                        # No history at all
 
2052
                        file_id = None
 
2053
                        kind = None
 
2054
                    else:
 
2055
                        tree1 = b.repository.revision_tree(rev1)
 
2056
                if tree1:
 
2057
                    file_id = tree1.path2id(fp)
 
2058
                    kind = _get_kind_for_file_id(tree1, file_id)
 
2059
            info_list.append((fp, file_id, kind))
 
2060
 
 
2061
    elif start_rev_info == end_rev_info:
 
2062
        # One revision given - file must exist in it
 
2063
        tree = b.repository.revision_tree(end_rev_info.rev_id)
 
2064
        for fp in relpaths:
 
2065
            file_id = tree.path2id(fp)
 
2066
            kind = _get_kind_for_file_id(tree, file_id)
 
2067
            info_list.append((fp, file_id, kind))
 
2068
 
 
2069
    else:
 
2070
        # Revision range given. Get the file-id from the end tree.
 
2071
        # If that fails, try the start tree.
 
2072
        rev_id = end_rev_info.rev_id
 
2073
        if rev_id is None:
 
2074
            tree = b.basis_tree()
 
2075
        else:
 
2076
            tree = b.repository.revision_tree(rev_id)
 
2077
        tree1 = None
 
2078
        for fp in relpaths:
 
2079
            file_id = tree.path2id(fp)
 
2080
            kind = _get_kind_for_file_id(tree, file_id)
 
2081
            if file_id is None:
 
2082
                if tree1 is None:
 
2083
                    rev_id = start_rev_info.rev_id
 
2084
                    if rev_id is None:
 
2085
                        rev1 = b.get_rev_id(1)
 
2086
                        tree1 = b.repository.revision_tree(rev1)
 
2087
                    else:
 
2088
                        tree1 = b.repository.revision_tree(rev_id)
 
2089
                file_id = tree1.path2id(fp)
 
2090
                kind = _get_kind_for_file_id(tree1, file_id)
 
2091
            info_list.append((fp, file_id, kind))
 
2092
    return b, info_list, start_rev_info, end_rev_info
 
2093
 
 
2094
 
 
2095
def _get_kind_for_file_id(tree, file_id):
 
2096
    """Return the kind of a file-id or None if it doesn't exist."""
 
2097
    if file_id is not None:
 
2098
        return tree.kind(file_id)
 
2099
    else:
 
2100
        return None
 
2101
 
 
2102
 
 
2103
properties_handler_registry = registry.Registry()
 
2104
 
 
2105
# Use the properties handlers to print out bug information if available
 
2106
def _bugs_properties_handler(revision):
 
2107
    if revision.properties.has_key('bugs'):
 
2108
        bug_lines = revision.properties['bugs'].split('\n')
 
2109
        bug_rows = [line.split(' ', 1) for line in bug_lines]
 
2110
        fixed_bug_urls = [row[0] for row in bug_rows if
 
2111
                          len(row) > 1 and row[1] == 'fixed']
 
2112
 
 
2113
        if fixed_bug_urls:
 
2114
            return {ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls)):\
 
2115
                    ' '.join(fixed_bug_urls)}
 
2116
    return {}
 
2117
 
 
2118
properties_handler_registry.register('bugs_properties_handler',
 
2119
                                     _bugs_properties_handler)
 
2120
 
 
2121
 
 
2122
# adapters which revision ids to log are filtered. When log is called, the
 
2123
# log_rev_iterator is adapted through each of these factory methods.
 
2124
# Plugins are welcome to mutate this list in any way they like - as long
 
2125
# as the overall behaviour is preserved. At this point there is no extensible
 
2126
# mechanism for getting parameters to each factory method, and until there is
 
2127
# this won't be considered a stable api.
 
2128
log_adapters = [
 
2129
    # core log logic
 
2130
    _make_batch_filter,
 
2131
    # read revision objects
 
2132
    _make_revision_objects,
 
2133
    # filter on log messages
 
2134
    _make_search_filter,
 
2135
    # generate deltas for things we will show
 
2136
    _make_delta_filter
 
2137
    ]