← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

[merge] John, sftp and others

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
28
28
 
29
29
* with file-ids and revision-ids shown
30
30
 
31
 
* from last to first or (not anymore) from first to last;
32
 
  the default is "reversed" because it shows the likely most
33
 
  relevant and interesting information first
34
 
 
35
 
* (not yet) in XML format
 
31
Logs are actually written out through an abstract LogFormatter
 
32
interface, which allows for different preferred formats.  Plugins can
 
33
register formats too.
 
34
 
 
35
Logs can be produced in either forward (oldest->newest) or reverse
 
36
(newest->oldest) order.
 
37
 
 
38
Logs can be filtered to show only revisions matching a particular
 
39
search string, or within a particular range of revisions.  The range
 
40
can be given as date/times, which are reduced to revisions before
 
41
calling in here.
 
42
 
 
43
In verbose mode we show a summary of what changed in each particular
 
44
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
 
46
logged revision.  So for example if you ask for a verbose log of
 
47
changes touching hello.c you will get a list of those revisions also
 
48
listing other things that were changed in the same revision, but not
 
49
all the changes since the previous revision that touched hello.c.
36
50
"""
37
51
 
38
52
 
39
 
from trace import mutter
 
53
# TODO: option to show delta summaries for merged-in revisions
 
54
 
 
55
import bzrlib.errors as errors
 
56
from bzrlib.tree import EmptyTree
 
57
from bzrlib.delta import compare_trees
 
58
from bzrlib.trace import mutter
 
59
import re
 
60
 
40
61
 
41
62
def find_touching_revisions(branch, file_id):
42
63
    """Yield a description of revisions which affect the file_id.
83
104
 
84
105
 
85
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
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
 
86
127
def show_log(branch,
87
128
             lf,
88
129
             specific_fileid=None,
113
154
    end_revision
114
155
        If not None, only show revisions <= end_revision
115
156
    """
 
157
    branch.lock_read()
 
158
    try:
 
159
        _show_log(branch, lf, specific_fileid, verbose, direction,
 
160
                  start_revision, end_revision, search)
 
161
    finally:
 
162
        branch.unlock()
 
163
    
 
164
def _show_log(branch,
 
165
             lf,
 
166
             specific_fileid=None,
 
167
             verbose=False,
 
168
             direction='reverse',
 
169
             start_revision=None,
 
170
             end_revision=None,
 
171
             search=None):
 
172
    """Worker function for show_log - see show_log."""
116
173
    from bzrlib.osutils import format_date
117
174
    from bzrlib.errors import BzrCheckError
118
175
    from bzrlib.textui import show_status
123
180
        warn("not a LogFormatter instance: %r" % lf)
124
181
 
125
182
    if specific_fileid:
126
 
        mutter('get log for file_id %r' % specific_fileid)
 
183
        mutter('get log for file_id %r', specific_fileid)
127
184
 
128
185
    if search is not None:
129
186
        import re
131
188
    else:
132
189
        searchRE = None
133
190
 
134
 
    which_revs = branch.enum_history(direction)
135
 
    which_revs = [x for x in which_revs if (
136
 
            (start_revision is None or x[0] >= start_revision)
137
 
            and (end_revision is None or x[0] <= end_revision))]
138
 
 
139
 
    if not (verbose or specific_fileid):
140
 
        # no need to know what changed between revisions
141
 
        with_deltas = deltas_for_log_dummy(branch, which_revs)
142
 
    elif direction == 'reverse':
143
 
        with_deltas = deltas_for_log_reverse(branch, which_revs)
144
 
    else:        
145
 
        with_deltas = deltas_for_log_forward(branch, which_revs)
146
 
 
147
 
    for revno, rev, delta in with_deltas:
 
191
    which_revs = _enumerate_history(branch)
 
192
    
 
193
    if start_revision is None:
 
194
        start_revision = 1
 
195
    else:
 
196
        branch.check_real_revno(start_revision)
 
197
    
 
198
    if end_revision is None:
 
199
        end_revision = len(which_revs)
 
200
    else:
 
201
        branch.check_real_revno(end_revision)
 
202
 
 
203
    # list indexes are 0-based; revisions are 1-based
 
204
    cut_revs = which_revs[(start_revision-1):(end_revision)]
 
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)
 
217
            
148
218
        if specific_fileid:
149
219
            if not delta.touches_file_id(specific_fileid):
150
220
                continue
153
223
            # although we calculated it, throw it away without display
154
224
            delta = None
155
225
 
156
 
        if searchRE is None or searchRE.search(rev.message):
157
 
            lf.show(revno, rev, delta)
158
 
 
 
226
        rev = branch.get_revision(rev_id)
 
227
 
 
228
        if searchRE:
 
229
            if not searchRE.search(rev.message):
 
230
                continue
 
231
 
 
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)
159
252
 
160
253
 
161
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
    """
 
259
    
162
260
    for revno, revision_id in which_revs:
163
261
        yield revno, branch.get_revision(revision_id), None
164
262
 
165
263
 
166
264
def deltas_for_log_reverse(branch, which_revs):
167
 
    """Compute deltas for display in reverse log.
168
 
 
169
 
    Given a sequence of (revno, revision_id) pairs, return
170
 
    (revno, rev, delta).
 
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)
171
275
 
172
276
    The delta is from the given revision to the next one in the
173
277
    sequence, which makes sense if the log is being displayed from
174
278
    newest to oldest.
175
279
    """
176
 
    from tree import EmptyTree
177
 
    from diff import compare_trees
178
 
    
179
280
    last_revno = last_revision_id = last_tree = None
180
281
    for revno, revision_id in which_revs:
181
282
        this_tree = branch.revision_tree(revision_id)
210
311
    sequence, which makes sense if the log is being displayed from
211
312
    newest to oldest.
212
313
    """
213
 
    from tree import EmptyTree
214
 
    from diff import compare_trees
215
 
 
216
314
    last_revno = last_revision_id = last_tree = None
217
315
    prev_tree = EmptyTree(branch.get_root_id())
218
316
 
237
335
 
238
336
class LogFormatter(object):
239
337
    """Abstract class to display log messages."""
240
 
    def __init__(self, to_file, show_ids=False, show_timezone=False):
 
338
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
241
339
        self.to_file = to_file
242
340
        self.show_ids = show_ids
243
341
        self.show_timezone = show_timezone
244
 
        
245
 
 
246
 
 
247
 
 
248
 
 
249
 
 
 
342
 
 
343
 
 
344
    def show(self, revno, rev, delta):
 
345
        raise NotImplementedError('not implemented in abstract base')
 
346
 
 
347
    def short_committer(self, rev):
 
348
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
 
349
    
 
350
    
250
351
class LongLogFormatter(LogFormatter):
251
352
    def show(self, revno, rev, delta):
252
 
        from osutils import format_date
253
 
 
 
353
        return self._show_helper(revno=revno, rev=rev, delta=delta)
 
354
 
 
355
    def show_merge(self, rev):
 
356
        return self._show_helper(rev=rev, indent='    ', merged=True, delta=None)
 
357
 
 
358
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
 
359
        """Show a revision, either merged or not."""
 
360
        from bzrlib.osutils import format_date
254
361
        to_file = self.to_file
255
 
 
256
 
        print >>to_file,  '-' * 60
257
 
        print >>to_file,  'revno:', revno
 
362
        print >>to_file,  indent+'-' * 60
 
363
        if revno is not None:
 
364
            print >>to_file,  'revno:', revno
 
365
        if merged:
 
366
            print >>to_file,  indent+'merged:', rev.revision_id
 
367
        elif self.show_ids:
 
368
            print >>to_file,  indent+'revision-id:', rev.revision_id
258
369
        if self.show_ids:
259
 
            print >>to_file,  'revision-id:', rev.revision_id
260
 
        print >>to_file,  'committer:', rev.committer
261
 
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
262
 
                                             self.show_timezone))
 
370
            for parent_id in rev.parent_ids:
 
371
                print >>to_file, indent+'parent:', parent_id
 
372
        print >>to_file,  indent+'committer:', rev.committer
 
373
        try:
 
374
            print >>to_file, indent+'branch nick: %s' % \
 
375
                rev.properties['branch-nick']
 
376
        except KeyError:
 
377
            pass
 
378
        date_str = format_date(rev.timestamp,
 
379
                               rev.timezone or 0,
 
380
                               self.show_timezone)
 
381
        print >>to_file,  indent+'timestamp: %s' % date_str
263
382
 
264
 
        print >>to_file,  'message:'
 
383
        print >>to_file,  indent+'message:'
265
384
        if not rev.message:
266
 
            print >>to_file,  '  (no message)'
 
385
            print >>to_file,  indent+'  (no message)'
267
386
        else:
268
 
            for l in rev.message.split('\n'):
269
 
                print >>to_file,  '  ' + l
270
 
 
 
387
            message = rev.message.rstrip('\r\n')
 
388
            for l in message.split('\n'):
 
389
                print >>to_file,  indent+'  ' + l
271
390
        if delta != None:
272
391
            delta.show(to_file, self.show_ids)
273
392
 
274
393
 
275
 
 
276
394
class ShortLogFormatter(LogFormatter):
277
395
    def show(self, revno, rev, delta):
278
396
        from bzrlib.osutils import format_date
279
397
 
280
398
        to_file = self.to_file
281
 
 
282
 
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
 
399
        date_str = format_date(rev.timestamp, rev.timezone or 0,
 
400
                            self.show_timezone)
 
401
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
283
402
                format_date(rev.timestamp, rev.timezone or 0,
284
 
                            self.show_timezone))
 
403
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
404
                           show_offset=False))
285
405
        if self.show_ids:
286
406
            print >>to_file,  '      revision-id:', rev.revision_id
287
407
        if not rev.message:
288
408
            print >>to_file,  '      (no message)'
289
409
        else:
290
 
            for l in rev.message.split('\n'):
 
410
            message = rev.message.rstrip('\r\n')
 
411
            for l in message.split('\n'):
291
412
                print >>to_file,  '      ' + l
292
413
 
 
414
        # TODO: Why not show the modified files in a shorter form as
 
415
        # well? rewrap them single lines of appropriate length
293
416
        if delta != None:
294
417
            delta.show(to_file, self.show_ids)
295
 
        print
296
 
 
297
 
 
 
418
        print >>to_file, ''
 
419
 
 
420
class LineLogFormatter(LogFormatter):
 
421
    def truncate(self, str, max_len):
 
422
        if len(str) <= max_len:
 
423
            return str
 
424
        return str[:max_len-3]+'...'
 
425
 
 
426
    def date_string(self, rev):
 
427
        from bzrlib.osutils import format_date
 
428
        return format_date(rev.timestamp, rev.timezone or 0, 
 
429
                           self.show_timezone, date_fmt="%Y-%m-%d",
 
430
                           show_offset=False)
 
431
 
 
432
    def message(self, rev):
 
433
        if not rev.message:
 
434
            return '(no message)'
 
435
        else:
 
436
            return rev.message
 
437
 
 
438
    def show(self, revno, rev, delta):
 
439
        print >> self.to_file, self.log_string(rev, 79) 
 
440
 
 
441
    def log_string(self, rev, max_chars):
 
442
        out = [self.truncate(self.short_committer(rev), 20)]
 
443
        out.append(self.date_string(rev))
 
444
        out.append(self.message(rev).replace('\n', ' '))
 
445
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
446
 
 
447
def line_log(rev, max_chars):
 
448
    lf = LineLogFormatter(None)
 
449
    return lf.log_string(rev, max_chars)
298
450
 
299
451
FORMATTERS = {'long': LongLogFormatter,
300
452
              'short': ShortLogFormatter,
 
453
              'line': LineLogFormatter,
301
454
              }
302
455
 
303
456
 
304
457
def log_formatter(name, *args, **kwargs):
 
458
    """Construct a formatter from arguments.
 
459
 
 
460
    name -- Name of the formatter to construct; currently 'long', 'short' and
 
461
        'line' are supported.
 
462
    """
305
463
    from bzrlib.errors import BzrCommandError
306
 
    
307
464
    try:
308
465
        return FORMATTERS[name](*args, **kwargs)
309
466
    except IndexError:
310
467
        raise BzrCommandError("unknown log formatter: %r" % name)
 
468
 
 
469
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
470
    # deprecated; for compatability
 
471
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
472
    lf.show(revno, rev, delta)
 
473
 
 
474
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
 
475
    """Show the change in revision history comparing the old revision history to the new one.
 
476
 
 
477
    :param branch: The branch where the revisions exist
 
478
    :param old_rh: The old revision history
 
479
    :param new_rh: The new revision history
 
480
    :param to_file: A file to write the results to. If None, stdout will be used
 
481
    """
 
482
    if to_file is None:
 
483
        import sys
 
484
        import codecs
 
485
        import bzrlib
 
486
        to_file = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
487
    lf = log_formatter(log_format,
 
488
                       show_ids=False,
 
489
                       to_file=to_file,
 
490
                       show_timezone='original')
 
491
 
 
492
    # This is the first index which is different between
 
493
    # old and new
 
494
    base_idx = None
 
495
    for i in xrange(max(len(new_rh),
 
496
                        len(old_rh))):
 
497
        if (len(new_rh) <= i
 
498
            or len(old_rh) <= i
 
499
            or new_rh[i] != old_rh[i]):
 
500
            base_idx = i
 
501
            break
 
502
 
 
503
    if base_idx is None:
 
504
        to_file.write('Nothing seems to have changed\n')
 
505
        return
 
506
    ## TODO: It might be nice to do something like show_log
 
507
    ##       and show the merged entries. But since this is the
 
508
    ##       removed revisions, it shouldn't be as important
 
509
    if base_idx < len(old_rh):
 
510
        to_file.write('*'*60)
 
511
        to_file.write('\nRemoved Revisions:\n')
 
512
        for i in range(base_idx, len(old_rh)):
 
513
            rev = branch.get_revision(old_rh[i])
 
514
            lf.show(i+1, rev, None)
 
515
        to_file.write('*'*60)
 
516
        to_file.write('\n\n')
 
517
    if base_idx < len(new_rh):
 
518
        to_file.write('Added Revisions:\n')
 
519
        show_log(branch,
 
520
                 lf,
 
521
                 None,
 
522
                 verbose=True,
 
523
                 direction='forward',
 
524
                 start_revision=base_idx+1,
 
525
                 end_revision=len(new_rh),
 
526
                 search=None)
 
527