← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
1
1
# Copyright (C) 2005 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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
49
49
all the changes since the previous revision that touched hello.c.
50
50
"""
51
51
 
52
 
 
53
52
# TODO: option to show delta summaries for merged-in revisions
 
53
 
 
54
from itertools import izip
54
55
import re
55
56
 
56
 
from bzrlib.delta import compare_trees
 
57
from bzrlib import(
 
58
    registry,
 
59
    symbol_versioning,
 
60
    )
57
61
import bzrlib.errors as errors
 
62
from bzrlib.symbol_versioning import deprecated_method, zero_eleven
58
63
from bzrlib.trace import mutter
59
 
from bzrlib.tree import EmptyTree
60
64
from bzrlib.tsort import merge_sort
61
65
 
62
66
 
114
118
    return rh
115
119
 
116
120
 
117
 
def _get_revision_delta(branch, revno):
118
 
    """Return the delta for a mainline revision.
119
 
    
120
 
    This is used to show summaries in verbose logs, and also for finding 
121
 
    revisions which touch a given file."""
122
 
    # XXX: What are we supposed to do when showing a summary for something 
123
 
    # other than a mainline revision.  The delta to it's first parent, or
124
 
    # (more useful) the delta to a nominated other revision.
125
 
    return branch.get_revision_delta(revno)
126
 
 
127
 
 
128
121
def show_log(branch,
129
122
             lf,
130
123
             specific_fileid=None,
173
166
    """Worker function for show_log - see show_log."""
174
167
    from bzrlib.osutils import format_date
175
168
    from bzrlib.errors import BzrCheckError
176
 
    from bzrlib.textui import show_status
177
169
    
178
170
    from warnings import warn
179
171
 
205
197
    cut_revs = which_revs[(start_revision-1):(end_revision)]
206
198
    if not cut_revs:
207
199
        return
 
200
 
 
201
    # convert the revision history to a dictionary:
 
202
    rev_nos = dict((k, v) for v, k in cut_revs)
 
203
 
208
204
    # override the mainline to look like the revision history.
209
205
    mainline_revs = [revision_id for index, revision_id in cut_revs]
210
206
    if cut_revs[0][0] == 1:
211
207
        mainline_revs.insert(0, None)
212
208
    else:
213
209
        mainline_revs.insert(0, which_revs[start_revision-2][1])
214
 
 
215
 
    merge_sorted_revisions = merge_sort(
216
 
        branch.repository.get_revision_graph(mainline_revs[-1]),
217
 
        mainline_revs[-1],
218
 
        mainline_revs)
219
 
 
220
 
    if direction == 'reverse':
221
 
        cut_revs.reverse()
222
 
    elif direction == 'forward':
223
 
        # forward means oldest first.
224
 
        merge_sorted_revisions.reverse()
 
210
    # how should we show merged revisions ?
 
211
    # old api: show_merge. New api: show_merge_revno
 
212
    show_merge_revno = getattr(lf, 'show_merge_revno', None)
 
213
    show_merge = getattr(lf, 'show_merge', None)
 
214
    if show_merge is None and show_merge_revno is None:
 
215
        # no merged-revno support
 
216
        include_merges = False
225
217
    else:
226
 
        raise ValueError('invalid direction %r' % direction)
227
 
 
228
 
    revision_history = branch.revision_history()
229
 
 
230
 
    # convert the revision history to a dictionary:
231
 
    rev_nos = {}
232
 
    for index, rev_id in cut_revs:
233
 
        rev_nos[rev_id] = index
234
 
 
 
218
        include_merges = True
 
219
    if show_merge is not None and show_merge_revno is None:
 
220
        # tell developers to update their code
 
221
        symbol_versioning.warn('LogFormatters should provide show_merge_revno '
 
222
            'instead of show_merge since bzr 0.11.',
 
223
            DeprecationWarning, stacklevel=3)
 
224
    view_revisions = list(get_view_revisions(mainline_revs, rev_nos, branch,
 
225
                          direction, include_merges=include_merges))
 
226
 
 
227
    def iter_revisions():
 
228
        # r = revision, n = revno, d = merge depth
 
229
        revision_ids = [r for r, n, d in view_revisions]
 
230
        zeros = set(r for r, n, d in view_revisions if d == 0)
 
231
        num = 9
 
232
        repository = branch.repository
 
233
        while revision_ids:
 
234
            cur_deltas = {}
 
235
            revisions = repository.get_revisions(revision_ids[:num])
 
236
            if verbose or specific_fileid:
 
237
                delta_revisions = [r for r in revisions if
 
238
                                   r.revision_id in zeros]
 
239
                deltas = repository.get_deltas_for_revisions(delta_revisions)
 
240
                cur_deltas = dict(izip((r.revision_id for r in 
 
241
                                        delta_revisions), deltas))
 
242
            for revision in revisions:
 
243
                # The delta value will be None unless
 
244
                # 1. verbose or specific_fileid is specified, and
 
245
                # 2. the revision is a mainline revision
 
246
                yield revision, cur_deltas.get(revision.revision_id)
 
247
            revision_ids  = revision_ids[num:]
 
248
            num = int(num * 1.5)
 
249
            
235
250
    # now we just print all the revisions
236
 
    for sequence, rev_id, merge_depth, end_of_merge in merge_sorted_revisions:
237
 
        rev = branch.repository.get_revision(rev_id)
 
251
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
 
252
         izip(view_revisions, iter_revisions()):
238
253
 
239
254
        if searchRE:
240
255
            if not searchRE.search(rev.message):
242
257
 
243
258
        if merge_depth == 0:
244
259
            # a mainline revision.
245
 
            if verbose or specific_fileid:
246
 
                delta = _get_revision_delta(branch, rev_nos[rev_id])
247
260
                
248
261
            if specific_fileid:
249
262
                if not delta.touches_file_id(specific_fileid):
253
266
                # although we calculated it, throw it away without display
254
267
                delta = None
255
268
 
256
 
            lf.show(rev_nos[rev_id], rev, delta)
257
 
        elif hasattr(lf, 'show_merge'):
258
 
            lf.show_merge(rev, merge_depth)
259
 
 
260
 
 
261
 
def deltas_for_log_dummy(branch, which_revs):
262
 
    """Return all the revisions without intermediate deltas.
263
 
 
264
 
    Useful for log commands that won't need the delta information.
265
 
    """
266
 
    
267
 
    for revno, revision_id in which_revs:
268
 
        yield revno, branch.get_revision(revision_id), None
269
 
 
270
 
 
271
 
def deltas_for_log_reverse(branch, which_revs):
272
 
    """Compute deltas for display in latest-to-earliest order.
273
 
 
274
 
    branch
275
 
        Branch to traverse
276
 
 
277
 
    which_revs
278
 
        Sequence of (revno, revision_id) for the subset of history to examine
279
 
 
280
 
    returns 
281
 
        Sequence of (revno, rev, delta)
282
 
 
283
 
    The delta is from the given revision to the next one in the
284
 
    sequence, which makes sense if the log is being displayed from
285
 
    newest to oldest.
286
 
    """
287
 
    last_revno = last_revision_id = last_tree = None
288
 
    for revno, revision_id in which_revs:
289
 
        this_tree = branch.revision_tree(revision_id)
290
 
        this_revision = branch.get_revision(revision_id)
291
 
        
292
 
        if last_revno:
293
 
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
294
 
 
295
 
        this_tree = EmptyTree(branch.get_root_id())
296
 
 
297
 
        last_revno = revno
298
 
        last_revision = this_revision
299
 
        last_tree = this_tree
300
 
 
301
 
    if last_revno:
302
 
        if last_revno == 1:
303
 
            this_tree = EmptyTree(branch.get_root_id())
 
269
            lf.show(revno, rev, delta)
304
270
        else:
305
 
            this_revno = last_revno - 1
306
 
            this_revision_id = branch.revision_history()[this_revno]
307
 
            this_tree = branch.revision_tree(this_revision_id)
308
 
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
309
 
 
310
 
 
311
 
def deltas_for_log_forward(branch, which_revs):
312
 
    """Compute deltas for display in forward log.
313
 
 
314
 
    Given a sequence of (revno, revision_id) pairs, return
315
 
    (revno, rev, delta).
316
 
 
317
 
    The delta is from the given revision to the next one in the
318
 
    sequence, which makes sense if the log is being displayed from
319
 
    newest to oldest.
320
 
    """
321
 
    last_revno = last_revision_id = last_tree = None
322
 
    prev_tree = EmptyTree(branch.get_root_id())
323
 
 
324
 
    for revno, revision_id in which_revs:
325
 
        this_tree = branch.revision_tree(revision_id)
326
 
        this_revision = branch.get_revision(revision_id)
327
 
 
328
 
        if not last_revno:
329
 
            if revno == 1:
330
 
                last_tree = EmptyTree(branch.get_root_id())
 
271
            if show_merge_revno is None:
 
272
                lf.show_merge(rev, merge_depth)
331
273
            else:
332
 
                last_revno = revno - 1
333
 
                last_revision_id = branch.revision_history()[last_revno]
334
 
                last_tree = branch.revision_tree(last_revision_id)
335
 
 
336
 
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
337
 
 
338
 
        last_revno = revno
339
 
        last_revision = this_revision
340
 
        last_tree = this_tree
 
274
                lf.show_merge_revno(rev, merge_depth, revno)
 
275
 
 
276
 
 
277
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
 
278
                       include_merges=True):
 
279
    """Produce an iterator of revisions to show
 
280
    :return: an iterator of (revision_id, revno, merge_depth)
 
281
    (if there is no revno for a revision, None is supplied)
 
282
    """
 
283
    if include_merges is False:
 
284
        revision_ids = mainline_revs[1:]
 
285
        if direction == 'reverse':
 
286
            revision_ids.reverse()
 
287
        for revision_id in revision_ids:
 
288
            yield revision_id, str(rev_nos[revision_id]), 0
 
289
        return
 
290
    merge_sorted_revisions = merge_sort(
 
291
        branch.repository.get_revision_graph(mainline_revs[-1]),
 
292
        mainline_revs[-1],
 
293
        mainline_revs,
 
294
        generate_revno=True)
 
295
 
 
296
    if direction == 'forward':
 
297
        # forward means oldest first.
 
298
        merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
 
299
    elif direction != 'reverse':
 
300
        raise ValueError('invalid direction %r' % direction)
 
301
 
 
302
    for sequence, rev_id, merge_depth, revno, end_of_merge in merge_sorted_revisions:
 
303
        yield rev_id, '.'.join(map(str, revno)), merge_depth
 
304
 
 
305
 
 
306
def reverse_by_depth(merge_sorted_revisions, _depth=0):
 
307
    """Reverse revisions by depth.
 
308
 
 
309
    Revisions with a different depth are sorted as a group with the previous
 
310
    revision of that depth.  There may be no topological justification for this,
 
311
    but it looks much nicer.
 
312
    """
 
313
    zd_revisions = []
 
314
    for val in merge_sorted_revisions:
 
315
        if val[2] == _depth:
 
316
            zd_revisions.append([val])
 
317
        else:
 
318
            assert val[2] > _depth
 
319
            zd_revisions[-1].append(val)
 
320
    for revisions in zd_revisions:
 
321
        if len(revisions) > 1:
 
322
            revisions[1:] = reverse_by_depth(revisions[1:], _depth + 1)
 
323
    zd_revisions.reverse()
 
324
    result = []
 
325
    for chunk in zd_revisions:
 
326
        result.extend(chunk)
 
327
    return result
341
328
 
342
329
 
343
330
class LogFormatter(object):
359
346
    def show(self, revno, rev, delta):
360
347
        return self._show_helper(revno=revno, rev=rev, delta=delta)
361
348
 
 
349
    @deprecated_method(zero_eleven)
362
350
    def show_merge(self, rev, merge_depth):
363
351
        return self._show_helper(rev=rev, indent='    '*merge_depth, merged=True, delta=None)
364
352
 
 
353
    def show_merge_revno(self, rev, merge_depth, revno):
 
354
        """Show a merged revision rev, with merge_depth and a revno."""
 
355
        return self._show_helper(rev=rev, revno=revno,
 
356
            indent='    '*merge_depth, merged=True, delta=None)
 
357
 
365
358
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
366
359
        """Show a revision, either merged or not."""
367
360
        from bzrlib.osutils import format_date
368
361
        to_file = self.to_file
369
362
        print >>to_file,  indent+'-' * 60
370
363
        if revno is not None:
371
 
            print >>to_file,  'revno:', revno
 
364
            print >>to_file,  indent+'revno:', revno
372
365
        if merged:
373
366
            print >>to_file,  indent+'merged:', rev.revision_id
374
367
        elif self.show_ids:
394
387
            message = rev.message.rstrip('\r\n')
395
388
            for l in message.split('\n'):
396
389
                print >>to_file,  indent+'  ' + l
397
 
        if delta != None:
 
390
        if delta is not None:
398
391
            delta.show(to_file, self.show_ids)
399
392
 
400
393
 
405
398
        to_file = self.to_file
406
399
        date_str = format_date(rev.timestamp, rev.timezone or 0,
407
400
                            self.show_timezone)
408
 
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
 
401
        print >>to_file, "%5s %s\t%s" % (revno, self.short_committer(rev),
409
402
                format_date(rev.timestamp, rev.timezone or 0,
410
403
                            self.show_timezone, date_fmt="%Y-%m-%d",
411
404
                           show_offset=False))
420
413
 
421
414
        # TODO: Why not show the modified files in a shorter form as
422
415
        # well? rewrap them single lines of appropriate length
423
 
        if delta != None:
 
416
        if delta is not None:
424
417
            delta.show(to_file, self.show_ids)
425
418
        print >>to_file, ''
426
419
 
458
451
        out = []
459
452
        if revno:
460
453
            # show revno only when is not None
461
 
            out.append("%d:" % revno)
 
454
            out.append("%s:" % revno)
462
455
        out.append(self.truncate(self.short_committer(rev), 20))
463
456
        out.append(self.date_string(rev))
464
 
        out.append(self.message(rev).replace('\n', ' '))
 
457
        out.append(rev.get_summary())
465
458
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
466
459
 
467
460
 
469
462
    lf = LineLogFormatter(None)
470
463
    return lf.log_string(None, rev, max_chars)
471
464
 
472
 
FORMATTERS = {
473
 
              'long': LongLogFormatter,
474
 
              'short': ShortLogFormatter,
475
 
              'line': LineLogFormatter,
476
 
              }
 
465
 
 
466
class LogFormatterRegistry(registry.Registry):
 
467
    """Registry for log formatters"""
 
468
 
 
469
    def make_formatter(self, name, *args, **kwargs):
 
470
        """Construct a formatter from arguments.
 
471
 
 
472
        :param name: Name of the formatter to construct.  'short', 'long' and
 
473
            'line' are built-in.
 
474
        """
 
475
        return self.get(name)(*args, **kwargs)
 
476
 
 
477
    def get_default(self, branch):
 
478
        return self.get(branch.get_config().log_format())
 
479
 
 
480
 
 
481
log_formatter_registry = LogFormatterRegistry()
 
482
 
 
483
 
 
484
log_formatter_registry.register('short', ShortLogFormatter,
 
485
                                'Moderately short log format')
 
486
log_formatter_registry.register('long', LongLogFormatter,
 
487
                                'Detailed log format')
 
488
log_formatter_registry.register('line', LineLogFormatter,
 
489
                                'Log format with one line per revision')
 
490
 
477
491
 
478
492
def register_formatter(name, formatter):
479
 
    FORMATTERS[name] = formatter
 
493
    log_formatter_registry.register(name, formatter)
 
494
 
480
495
 
481
496
def log_formatter(name, *args, **kwargs):
482
497
    """Construct a formatter from arguments.
486
501
    """
487
502
    from bzrlib.errors import BzrCommandError
488
503
    try:
489
 
        return FORMATTERS[name](*args, **kwargs)
 
504
        return log_formatter_registry.make_formatter(name, *args, **kwargs)
490
505
    except KeyError:
491
506
        raise BzrCommandError("unknown log formatter: %r" % name)
492
507
 
 
508
 
493
509
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
494
 
    # deprecated; for compatability
 
510
    # deprecated; for compatibility
495
511
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
496
512
    lf.show(revno, rev, delta)
497
513