← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

Refactor status display code.

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
 
52
53
# TODO: option to show delta summaries for merged-in revisions
53
54
 
54
 
from itertools import izip
55
 
import re
56
 
 
57
55
import bzrlib.errors as errors
 
56
from bzrlib.tree import EmptyTree
 
57
from bzrlib.delta import compare_trees
58
58
from bzrlib.trace import mutter
59
 
from bzrlib.tsort import merge_sort
 
59
import re
60
60
 
61
61
 
62
62
def find_touching_revisions(branch, file_id):
74
74
    last_path = None
75
75
    revno = 1
76
76
    for revision_id in branch.revision_history():
77
 
        this_inv = branch.repository.get_revision_inventory(revision_id)
 
77
        this_inv = branch.get_revision_inventory(revision_id)
78
78
        if file_id in this_inv:
79
79
            this_ie = this_inv[file_id]
80
80
            this_path = this_inv.id2path(file_id)
113
113
    return rh
114
114
 
115
115
 
 
116
def _get_revision_delta(branch, revno):
 
117
    """Return the delta for a mainline revision.
 
118
    
 
119
    This is used to show summaries in verbose logs, and also for finding 
 
120
    revisions which touch a given file."""
 
121
    # XXX: What are we supposed to do when showing a summary for something 
 
122
    # other than a mainline revision.  The delta to it's first parent, or
 
123
    # (more useful) the delta to a nominated other revision.
 
124
    return branch.get_revision_delta(revno)
 
125
 
 
126
 
116
127
def show_log(branch,
117
128
             lf,
118
129
             specific_fileid=None,
161
172
    """Worker function for show_log - see show_log."""
162
173
    from bzrlib.osutils import format_date
163
174
    from bzrlib.errors import BzrCheckError
 
175
    from bzrlib.textui import show_status
164
176
    
165
177
    from warnings import warn
166
178
 
190
202
 
191
203
    # list indexes are 0-based; revisions are 1-based
192
204
    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)
198
 
 
199
 
    # 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)
 
205
 
 
206
    if direction == 'reverse':
 
207
        cut_revs.reverse()
 
208
    elif direction == 'forward':
 
209
        pass
 
210
    else:
 
211
        raise ValueError('invalid direction %r' % direction)
 
212
 
 
213
    revision_history = branch.revision_history()
 
214
    for revno, rev_id in cut_revs:
 
215
        if verbose or specific_fileid:
 
216
            delta = _get_revision_delta(branch, revno)
234
217
            
235
 
    # now we just print all the revisions
236
 
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
237
 
         izip(view_revisions, iter_revisions()):
 
218
        if specific_fileid:
 
219
            if not delta.touches_file_id(specific_fileid):
 
220
                continue
 
221
 
 
222
        if not verbose:
 
223
            # although we calculated it, throw it away without display
 
224
            delta = None
 
225
 
 
226
        rev = branch.get_revision(rev_id)
238
227
 
239
228
        if searchRE:
240
229
            if not searchRE.search(rev.message):
241
230
                continue
242
231
 
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
 
232
        lf.show(revno, rev, delta)
 
233
        if hasattr(lf, 'show_merge'):
 
234
            if revno == 1:
 
235
                excludes = set()
 
236
            else:
 
237
                # revno is 1 based, so -2 to get back 1 less.
 
238
                excludes = set(branch.get_ancestry(revision_history[revno - 2]))
 
239
            pending = list(rev.parent_ids)
 
240
            while pending:
 
241
                rev_id = pending.pop()
 
242
                if rev_id in excludes:
 
243
                    continue
 
244
                # prevent showing merged revs twice if they multi-path.
 
245
                excludes.add(rev_id)
 
246
                try:
 
247
                    rev = branch.get_revision(rev_id)
 
248
                except errors.NoSuchRevision:
 
249
                    continue
 
250
                pending.extend(rev.parent_ids)
 
251
                lf.show_merge(rev)
 
252
 
 
253
 
 
254
def deltas_for_log_dummy(branch, which_revs):
 
255
    """Return all the revisions without intermediate deltas.
 
256
 
 
257
    Useful for log commands that won't need the delta information.
 
258
    """
249
259
    
250
 
            if not verbose:
251
 
                # although we calculated it, throw it away without display
252
 
                delta = None
253
 
 
254
 
            lf.show(revno, rev, delta)
255
 
        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
287
 
 
288
 
 
289
 
def reverse_by_depth(merge_sorted_revisions, _depth=0):
290
 
    """Reverse revisions by depth.
291
 
 
292
 
    Revisions with a different depth are sorted as a group with the previous
293
 
    revision of that depth.  There may be no topological justification for this,
294
 
    but it looks much nicer.
295
 
    """
296
 
    zd_revisions = []
297
 
    for val in merge_sorted_revisions:
298
 
        if val[2] == _depth:
299
 
            zd_revisions.append([val])
300
 
        else:
301
 
            assert val[2] > _depth
302
 
            zd_revisions[-1].append(val)
303
 
    for revisions in zd_revisions:
304
 
        if len(revisions) > 1:
305
 
            revisions[1:] = reverse_by_depth(revisions[1:], _depth + 1)
306
 
    zd_revisions.reverse()
307
 
    result = []
308
 
    for chunk in zd_revisions:
309
 
        result.extend(chunk)
310
 
    return result
 
260
    for revno, revision_id in which_revs:
 
261
        yield revno, branch.get_revision(revision_id), None
 
262
 
 
263
 
 
264
def deltas_for_log_reverse(branch, which_revs):
 
265
    """Compute deltas for display in latest-to-earliest order.
 
266
 
 
267
    branch
 
268
        Branch to traverse
 
269
 
 
270
    which_revs
 
271
        Sequence of (revno, revision_id) for the subset of history to examine
 
272
 
 
273
    returns 
 
274
        Sequence of (revno, rev, delta)
 
275
 
 
276
    The delta is from the given revision to the next one in the
 
277
    sequence, which makes sense if the log is being displayed from
 
278
    newest to oldest.
 
279
    """
 
280
    last_revno = last_revision_id = last_tree = None
 
281
    for revno, revision_id in which_revs:
 
282
        this_tree = branch.revision_tree(revision_id)
 
283
        this_revision = branch.get_revision(revision_id)
 
284
        
 
285
        if last_revno:
 
286
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
287
 
 
288
        this_tree = EmptyTree(branch.get_root_id())
 
289
 
 
290
        last_revno = revno
 
291
        last_revision = this_revision
 
292
        last_tree = this_tree
 
293
 
 
294
    if last_revno:
 
295
        if last_revno == 1:
 
296
            this_tree = EmptyTree(branch.get_root_id())
 
297
        else:
 
298
            this_revno = last_revno - 1
 
299
            this_revision_id = branch.revision_history()[this_revno]
 
300
            this_tree = branch.revision_tree(this_revision_id)
 
301
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
302
 
 
303
 
 
304
def deltas_for_log_forward(branch, which_revs):
 
305
    """Compute deltas for display in forward log.
 
306
 
 
307
    Given a sequence of (revno, revision_id) pairs, return
 
308
    (revno, rev, delta).
 
309
 
 
310
    The delta is from the given revision to the next one in the
 
311
    sequence, which makes sense if the log is being displayed from
 
312
    newest to oldest.
 
313
    """
 
314
    last_revno = last_revision_id = last_tree = None
 
315
    prev_tree = EmptyTree(branch.get_root_id())
 
316
 
 
317
    for revno, revision_id in which_revs:
 
318
        this_tree = branch.revision_tree(revision_id)
 
319
        this_revision = branch.get_revision(revision_id)
 
320
 
 
321
        if not last_revno:
 
322
            if revno == 1:
 
323
                last_tree = EmptyTree(branch.get_root_id())
 
324
            else:
 
325
                last_revno = revno - 1
 
326
                last_revision_id = branch.revision_history()[last_revno]
 
327
                last_tree = branch.revision_tree(last_revision_id)
 
328
 
 
329
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
330
 
 
331
        last_revno = revno
 
332
        last_revision = this_revision
 
333
        last_tree = this_tree
311
334
 
312
335
 
313
336
class LogFormatter(object):
314
337
    """Abstract class to display log messages."""
315
 
 
316
338
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
317
339
        self.to_file = to_file
318
340
        self.show_ids = show_ids
319
341
        self.show_timezone = show_timezone
320
342
 
 
343
 
321
344
    def show(self, revno, rev, delta):
322
345
        raise NotImplementedError('not implemented in abstract base')
323
346
 
329
352
    def show(self, revno, rev, delta):
330
353
        return self._show_helper(revno=revno, rev=rev, delta=delta)
331
354
 
332
 
    def show_merge(self, rev, merge_depth):
333
 
        return self._show_helper(rev=rev, indent='    '*merge_depth, merged=True, delta=None)
 
355
    def show_merge(self, rev):
 
356
        return self._show_helper(rev=rev, indent='    ', merged=True, delta=None)
334
357
 
335
358
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
336
 
        """Show a revision, either merged or not."""
 
359
        """Show a revision, either merged or not."""
337
360
        from bzrlib.osutils import format_date
338
361
        to_file = self.to_file
339
362
        print >>to_file,  indent+'-' * 60
364
387
            message = rev.message.rstrip('\r\n')
365
388
            for l in message.split('\n'):
366
389
                print >>to_file,  indent+'  ' + l
367
 
        if delta is not None:
 
390
        if delta != None:
368
391
            delta.show(to_file, self.show_ids)
369
392
 
370
393
 
390
413
 
391
414
        # TODO: Why not show the modified files in a shorter form as
392
415
        # well? rewrap them single lines of appropriate length
393
 
        if delta is not None:
 
416
        if delta != None:
394
417
            delta.show(to_file, self.show_ids)
395
418
        print >>to_file, ''
396
419
 
397
 
 
398
420
class LineLogFormatter(LogFormatter):
399
421
    def truncate(self, str, max_len):
400
422
        if len(str) <= max_len:
414
436
            return rev.message
415
437
 
416
438
    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)
 
439
        print >> self.to_file, self.log_string(rev, 79) 
419
440
 
420
 
    def log_string(self, revno, rev, max_chars):
421
 
        """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
427
 
        """
428
 
        out = []
429
 
        if revno:
430
 
            # show revno only when is not None
431
 
            out.append("%d:" % revno)
432
 
        out.append(self.truncate(self.short_committer(rev), 20))
 
441
    def log_string(self, rev, max_chars):
 
442
        out = [self.truncate(self.short_committer(rev), 20)]
433
443
        out.append(self.date_string(rev))
434
 
        out.append(rev.get_summary())
 
444
        out.append(self.message(rev).replace('\n', ' '))
435
445
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
436
446
 
437
 
 
438
447
def line_log(rev, max_chars):
439
448
    lf = LineLogFormatter(None)
440
 
    return lf.log_string(None, rev, max_chars)
 
449
    return lf.log_string(rev, max_chars)
441
450
 
442
 
FORMATTERS = {
443
 
              'long': LongLogFormatter,
 
451
FORMATTERS = {'long': LongLogFormatter,
444
452
              'short': ShortLogFormatter,
445
453
              'line': LineLogFormatter,
446
454
              }
447
455
 
448
 
def register_formatter(name, formatter):
449
 
    FORMATTERS[name] = formatter
450
456
 
451
457
def log_formatter(name, *args, **kwargs):
452
458
    """Construct a formatter from arguments.
457
463
    from bzrlib.errors import BzrCommandError
458
464
    try:
459
465
        return FORMATTERS[name](*args, **kwargs)
460
 
    except KeyError:
 
466
    except IndexError:
461
467
        raise BzrCommandError("unknown log formatter: %r" % name)
462
468
 
463
469
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
464
 
    # deprecated; for compatibility
 
470
    # deprecated; for compatability
465
471
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
466
472
    lf.show(revno, rev, delta)
467
473
 
504
510
        to_file.write('*'*60)
505
511
        to_file.write('\nRemoved Revisions:\n')
506
512
        for i in range(base_idx, len(old_rh)):
507
 
            rev = branch.repository.get_revision(old_rh[i])
 
513
            rev = branch.get_revision(old_rh[i])
508
514
            lf.show(i+1, rev, None)
509
515
        to_file.write('*'*60)
510
516
        to_file.write('\n\n')