~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Patch Queue Manager
  • Date: 2012-12-10 10:18:33 UTC
  • mfrom: (6571.1.2 1086209-lc-all-c)
  • Revision ID: pqm@pqm.ubuntu.com-20121210101833-06scfp3a4w0x0z87
(vila) Fix LC_ALL=C test failures related to utf8 stderr encoding (Vincent
 Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
 
52
 
# TODO: option to show delta summaries for merged-in revisions
 
50
from __future__ import absolute_import
53
51
 
54
 
from itertools import izip
 
52
import codecs
 
53
from cStringIO import StringIO
 
54
from itertools import (
 
55
    chain,
 
56
    izip,
 
57
    )
55
58
import re
56
 
 
57
 
import bzrlib.errors as errors
58
 
from bzrlib.trace import mutter
59
 
from bzrlib.tsort import merge_sort
 
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
    )
60
92
 
61
93
 
62
94
def find_touching_revisions(branch, file_id):
73
105
    last_ie = None
74
106
    last_path = None
75
107
    revno = 1
76
 
    for revision_id in branch.revision_history():
77
 
        this_inv = branch.repository.get_revision_inventory(revision_id)
78
 
        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):
79
114
            this_ie = this_inv[file_id]
80
115
            this_path = this_inv.id2path(file_id)
81
116
        else:
103
138
        revno += 1
104
139
 
105
140
 
106
 
 
107
 
def _enumerate_history(branch):
108
 
    rh = []
109
 
    revno = 1
110
 
    for rev_id in branch.revision_history():
111
 
        rh.append((revno, rev_id))
112
 
        revno += 1
113
 
    return rh
114
 
 
115
 
 
116
141
def show_log(branch,
117
142
             lf,
118
143
             specific_fileid=None,
120
145
             direction='reverse',
121
146
             start_revision=None,
122
147
             end_revision=None,
123
 
             search=None):
 
148
             search=None,
 
149
             limit=None,
 
150
             show_diff=False,
 
151
             match=None):
124
152
    """Write out human-readable log of commits to this branch.
125
153
 
126
 
    lf
127
 
        LogFormatter object to show the output.
128
 
 
129
 
    specific_fileid
130
 
        If true, list only the commits affecting the specified
131
 
        file, rather than all commits.
132
 
 
133
 
    verbose
134
 
        If true show added/changed/deleted/renamed files.
135
 
 
136
 
    direction
137
 
        'reverse' (default) is latest to earliest;
138
 
        'forward' is earliest to latest.
139
 
 
140
 
    start_revision
141
 
        If not None, only show revisions >= start_revision
142
 
 
143
 
    end_revision
144
 
        If not None, only show revisions <= end_revision
145
 
    """
146
 
    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 "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
    """
147
683
    try:
148
 
        _show_log(branch, lf, specific_fileid, verbose, direction,
149
 
                  start_revision, end_revision, search)
150
 
    finally:
151
 
        branch.unlock()
152
 
    
153
 
def _show_log(branch,
154
 
             lf,
155
 
             specific_fileid=None,
156
 
             verbose=False,
157
 
             direction='reverse',
158
 
             start_revision=None,
159
 
             end_revision=None,
160
 
             search=None):
161
 
    """Worker function for show_log - see show_log."""
162
 
    from bzrlib.osutils import format_date
163
 
    from bzrlib.errors import BzrCheckError
164
 
    
165
 
    from warnings import warn
166
 
 
167
 
    if not isinstance(lf, LogFormatter):
168
 
        warn("not a LogFormatter instance: %r" % lf)
169
 
 
170
 
    if specific_fileid:
171
 
        mutter('get log for file_id %r', specific_fileid)
172
 
 
173
 
    if search is not None:
174
 
        import re
175
 
        searchRE = re.compile(search, re.IGNORECASE)
176
 
    else:
177
 
        searchRE = None
178
 
 
179
 
    which_revs = _enumerate_history(branch)
180
 
    
181
 
    if start_revision is None:
182
 
        start_revision = 1
183
 
    else:
184
 
        branch.check_real_revno(start_revision)
185
 
    
186
 
    if end_revision is None:
187
 
        end_revision = len(which_revs)
188
 
    else:
189
 
        branch.check_real_revno(end_revision)
190
 
 
191
 
    # list indexes are 0-based; revisions are 1-based
192
 
    cut_revs = which_revs[(start_revision-1):(end_revision)]
193
 
    if not cut_revs:
194
 
        return
195
 
 
196
 
    # convert the revision history to a dictionary:
197
 
    rev_nos = dict((k, v) for v, k in cut_revs)
 
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()
198
1156
 
199
1157
    # override the mainline to look like the revision history.
200
 
    mainline_revs = [revision_id for index, revision_id in cut_revs]
201
 
    if cut_revs[0][0] == 1:
202
 
        mainline_revs.insert(0, None)
203
 
    else:
204
 
        mainline_revs.insert(0, which_revs[start_revision-2][1])
205
 
    if getattr(lf, 'show_merge', None) is not None:
206
 
        include_merges = True 
207
 
    else:
208
 
        include_merges = False 
209
 
    view_revisions = list(get_view_revisions(mainline_revs, rev_nos, branch,
210
 
                          direction, include_merges=include_merges))
211
 
 
212
 
    def iter_revisions():
213
 
        # r = revision, n = revno, d = merge depth
214
 
        revision_ids = [r for r, n, d in view_revisions]
215
 
        zeros = set(r for r, n, d in view_revisions if d == 0)
216
 
        num = 9
217
 
        repository = branch.repository
218
 
        while revision_ids:
219
 
            cur_deltas = {}
220
 
            revisions = repository.get_revisions(revision_ids[:num])
221
 
            if verbose or specific_fileid:
222
 
                delta_revisions = [r for r in revisions if
223
 
                                   r.revision_id in zeros]
224
 
                deltas = repository.get_deltas_for_revisions(delta_revisions)
225
 
                cur_deltas = dict(izip((r.revision_id for r in 
226
 
                                        delta_revisions), deltas))
227
 
            for revision in revisions:
228
 
                # The delta value will be None unless
229
 
                # 1. verbose or specific_fileid is specified, and
230
 
                # 2. the revision is a mainline revision
231
 
                yield revision, cur_deltas.get(revision.revision_id)
232
 
            revision_ids  = revision_ids[num:]
233
 
            num = int(num * 1.5)
234
 
            
235
 
    # now we just print all the revisions
236
 
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
237
 
         izip(view_revisions, iter_revisions()):
238
 
 
239
 
        if searchRE:
240
 
            if not searchRE.search(rev.message):
241
 
                continue
242
 
 
243
 
        if merge_depth == 0:
244
 
            # a mainline revision.
245
 
                
246
 
            if specific_fileid:
247
 
                if not delta.touches_file_id(specific_fileid):
248
 
                    continue
249
 
    
250
 
            if not verbose:
251
 
                # although we calculated it, throw it away without display
252
 
                delta = None
253
 
 
254
 
            lf.show(revno, rev, delta)
 
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)
255
1230
        else:
256
 
            lf.show_merge(rev, merge_depth)
257
 
 
258
 
 
259
 
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
260
 
                       include_merges=True):
261
 
    """Produce an iterator of revisions to show
262
 
    :return: an iterator of (revision_id, revno, merge_depth)
263
 
    (if there is no revno for a revision, None is supplied)
264
 
    """
265
 
    if include_merges is False:
266
 
        revision_ids = mainline_revs[1:]
267
 
        if direction == 'reverse':
268
 
            revision_ids.reverse()
269
 
        for revision_id in revision_ids:
270
 
            yield revision_id, rev_nos[revision_id], 0
271
 
        return
272
 
    merge_sorted_revisions = merge_sort(
273
 
        branch.repository.get_revision_graph(mainline_revs[-1]),
274
 
        mainline_revs[-1],
275
 
        mainline_revs)
276
 
 
277
 
    if direction == 'forward':
278
 
        # forward means oldest first.
279
 
        merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
280
 
    elif direction != 'reverse':
281
 
        raise ValueError('invalid direction %r' % direction)
282
 
 
283
 
    revision_history = branch.revision_history()
284
 
 
285
 
    for sequence, rev_id, merge_depth, end_of_merge in merge_sorted_revisions:
286
 
        yield rev_id, rev_nos.get(rev_id), merge_depth
 
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
287
1243
 
288
1244
 
289
1245
def reverse_by_depth(merge_sorted_revisions, _depth=0):
293
1249
    revision of that depth.  There may be no topological justification for this,
294
1250
    but it looks much nicer.
295
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
296
1254
    zd_revisions = []
297
1255
    for val in merge_sorted_revisions:
298
1256
        if val[2] == _depth:
 
1257
            # Each revision at the current depth becomes a chunk grouping all
 
1258
            # higher depth revisions.
299
1259
            zd_revisions.append([val])
300
1260
        else:
301
 
            assert val[2] > _depth
302
1261
            zd_revisions[-1].append(val)
303
1262
    for revisions in zd_revisions:
304
1263
        if len(revisions) > 1:
 
1264
            # We have higher depth revisions, let reverse them locally
305
1265
            revisions[1:] = reverse_by_depth(revisions[1:], _depth + 1)
306
1266
    zd_revisions.reverse()
307
1267
    result = []
308
1268
    for chunk in zd_revisions:
309
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]
310
1273
    return result
311
1274
 
312
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
 
1296
 
 
1297
 
313
1298
class LogFormatter(object):
314
 
    """Abstract class to display log messages."""
315
 
 
316
 
    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
        """
317
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)
318
1370
        self.show_ids = show_ids
319
1371
        self.show_timezone = show_timezone
320
 
 
321
 
    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
        """
322
1395
        raise NotImplementedError('not implemented in abstract base')
323
1396
 
 
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
 
324
1410
    def short_committer(self, rev):
325
 
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
326
 
    
327
 
    
 
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
 
328
1520
class LongLogFormatter(LogFormatter):
329
 
    def show(self, revno, rev, delta):
330
 
        return self._show_helper(revno=revno, rev=rev, delta=delta)
331
 
 
332
 
    def show_merge(self, rev, merge_depth):
333
 
        return self._show_helper(rev=rev, indent='    '*merge_depth, merged=True, delta=None)
334
 
 
335
 
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
336
 
        """Show a revision, either merged or not."""
337
 
        from bzrlib.osutils import format_date
338
 
        to_file = self.to_file
339
 
        print >>to_file,  indent+'-' * 60
340
 
        if revno is not None:
341
 
            print >>to_file,  'revno:', revno
342
 
        if merged:
343
 
            print >>to_file,  indent+'merged:', rev.revision_id
344
 
        elif self.show_ids:
345
 
            print >>to_file,  indent+'revision-id:', rev.revision_id
 
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,))
346
1555
        if self.show_ids:
347
 
            for parent_id in rev.parent_ids:
348
 
                print >>to_file, indent+'parent:', parent_id
349
 
        print >>to_file,  indent+'committer:', rev.committer
350
 
        try:
351
 
            print >>to_file, indent+'branch nick: %s' % \
352
 
                rev.properties['branch-nick']
353
 
        except KeyError:
354
 
            pass
355
 
        date_str = format_date(rev.timestamp,
356
 
                               rev.timezone or 0,
357
 
                               self.show_timezone)
358
 
        print >>to_file,  indent+'timestamp: %s' % date_str
359
 
 
360
 
        print >>to_file,  indent+'message:'
361
 
        if not rev.message:
362
 
            print >>to_file,  indent+'  (no message)'
 
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)')
363
1578
        else:
364
 
            message = rev.message.rstrip('\r\n')
 
1579
            message = revision.rev.message.rstrip('\r\n')
365
1580
            for l in message.split('\n'):
366
 
                print >>to_file,  indent+'  ' + l
367
 
        if delta != None:
368
 
            delta.show(to_file, self.show_ids)
 
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'
369
1602
 
370
1603
 
371
1604
class ShortLogFormatter(LogFormatter):
372
 
    def show(self, revno, rev, delta):
373
 
        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)
374
1635
 
375
1636
        to_file = self.to_file
376
 
        date_str = format_date(rev.timestamp, rev.timezone or 0,
377
 
                            self.show_timezone)
378
 
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
379
 
                format_date(rev.timestamp, rev.timezone or 0,
 
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,
380
1644
                            self.show_timezone, date_fmt="%Y-%m-%d",
381
 
                           show_offset=False))
382
 
        if self.show_ids:
383
 
            print >>to_file,  '      revision-id:', rev.revision_id
384
 
        if not rev.message:
385
 
            print >>to_file,  '      (no message)'
 
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')
386
1653
        else:
387
 
            message = rev.message.rstrip('\r\n')
 
1654
            message = revision.rev.message.rstrip('\r\n')
388
1655
            for l in message.split('\n'):
389
 
                print >>to_file,  '      ' + l
 
1656
                to_file.write(indent + offset + '%s\n' % (l,))
390
1657
 
391
 
        # TODO: Why not show the modified files in a shorter form as
392
 
        # well? rewrap them single lines of appropriate length
393
 
        if delta != None:
394
 
            delta.show(to_file, self.show_ids)
395
 
        print >>to_file, ''
 
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')
396
1667
 
397
1668
 
398
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
 
399
1683
    def truncate(self, str, max_len):
400
 
        if len(str) <= max_len:
 
1684
        if max_len is None or len(str) <= max_len:
401
1685
            return str
402
 
        return str[:max_len-3]+'...'
 
1686
        return str[:max_len-3] + '...'
403
1687
 
404
1688
    def date_string(self, rev):
405
 
        from bzrlib.osutils import format_date
406
 
        return format_date(rev.timestamp, rev.timezone or 0, 
 
1689
        return format_date(rev.timestamp, rev.timezone or 0,
407
1690
                           self.show_timezone, date_fmt="%Y-%m-%d",
408
1691
                           show_offset=False)
409
1692
 
413
1696
        else:
414
1697
            return rev.message
415
1698
 
416
 
    def show(self, revno, rev, delta):
417
 
        from bzrlib.osutils import terminal_width
418
 
        print >> self.to_file, self.log_string(revno, rev, terminal_width()-1)
 
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')
419
1704
 
420
 
    def log_string(self, revno, rev, max_chars):
 
1705
    def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
421
1706
        """Format log info into one string. Truncate tail of string
422
 
        :param  revno:      revision number (int) or None.
423
 
                            Revision numbers counts from 1.
424
 
        :param  rev:        revision info object
425
 
        :param  max_chars:  maximum length of resulting string
426
 
        :return:            formatted truncated 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
427
1715
        """
428
1716
        out = []
429
1717
        if revno:
430
1718
            # show revno only when is not None
431
 
            out.append("%d:" % revno)
432
 
        out.append(self.truncate(self.short_committer(rev), 20))
 
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))
433
1724
        out.append(self.date_string(rev))
 
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)
434
1730
        out.append(rev.get_summary())
435
 
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
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')
436
1769
 
437
1770
 
438
1771
def line_log(rev, max_chars):
439
1772
    lf = LineLogFormatter(None)
440
1773
    return lf.log_string(None, rev, max_chars)
441
1774
 
442
 
FORMATTERS = {
443
 
              'long': LongLogFormatter,
444
 
              'short': ShortLogFormatter,
445
 
              'line': LineLogFormatter,
446
 
              }
 
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
 
447
1804
 
448
1805
def register_formatter(name, formatter):
449
 
    FORMATTERS[name] = formatter
 
1806
    log_formatter_registry.register(name, formatter)
 
1807
 
450
1808
 
451
1809
def log_formatter(name, *args, **kwargs):
452
1810
    """Construct a formatter from arguments.
454
1812
    name -- Name of the formatter to construct; currently 'long', 'short' and
455
1813
        'line' are supported.
456
1814
    """
457
 
    from bzrlib.errors import BzrCommandError
458
1815
    try:
459
 
        return FORMATTERS[name](*args, **kwargs)
 
1816
        return log_formatter_registry.make_formatter(name, *args, **kwargs)
460
1817
    except KeyError:
461
 
        raise BzrCommandError("unknown log formatter: %r" % name)
462
 
 
463
 
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
464
 
    # deprecated; for compatibility
465
 
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
466
 
    lf.show(revno, rev, delta)
467
 
 
468
 
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
 
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]]
 
1829
    except IndexError:
 
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'):
469
1851
    """Show the change in revision history comparing the old revision history to the new one.
470
1852
 
471
1853
    :param branch: The branch where the revisions exist
474
1856
    :param to_file: A file to write the results to. If None, stdout will be used
475
1857
    """
476
1858
    if to_file is None:
477
 
        import sys
478
 
        import codecs
479
 
        import bzrlib
480
 
        to_file = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
1859
        to_file = codecs.getwriter(get_terminal_encoding())(sys.stdout,
 
1860
            errors='replace')
481
1861
    lf = log_formatter(log_format,
482
1862
                       show_ids=False,
483
1863
                       to_file=to_file,
505
1885
        to_file.write('\nRemoved Revisions:\n')
506
1886
        for i in range(base_idx, len(old_rh)):
507
1887
            rev = branch.repository.get_revision(old_rh[i])
508
 
            lf.show(i+1, rev, None)
 
1888
            lr = LogRevision(rev, i+1, 0, None)
 
1889
            lf.log_revision(lr)
509
1890
        to_file.write('*'*60)
510
1891
        to_file.write('\n\n')
511
1892
    if base_idx < len(new_rh):
513
1894
        show_log(branch,
514
1895
                 lf,
515
1896
                 None,
516
 
                 verbose=True,
 
1897
                 verbose=False,
517
1898
                 direction='forward',
518
1899
                 start_revision=base_idx+1,
519
1900
                 end_revision=len(new_rh),
520
1901
                 search=None)
521
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
    ]