~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

Exclude more files from dumb-rsync upload

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
import bzrlib.errors as errors
 
54
from bzrlib.tree import EmptyTree
 
55
from bzrlib.delta import compare_trees
 
56
from bzrlib.trace import mutter
 
57
import re
 
58
 
40
59
 
41
60
def find_touching_revisions(branch, file_id):
42
61
    """Yield a description of revisions which affect the file_id.
83
102
 
84
103
 
85
104
 
 
105
def _enumerate_history(branch):
 
106
    rh = []
 
107
    revno = 1
 
108
    for rev_id in branch.revision_history():
 
109
        rh.append((revno, rev_id))
 
110
        revno += 1
 
111
    return rh
 
112
 
 
113
 
 
114
def _get_revision_delta(branch, revno):
 
115
    """Return the delta for a mainline revision.
 
116
    
 
117
    This is used to show summaries in verbose logs, and also for finding 
 
118
    revisions which touch a given file."""
 
119
    # XXX: What are we supposed to do when showing a summary for something 
 
120
    # other than a mainline revision.  The delta to it's first parent, or
 
121
    # (more useful) the delta to a nominated other revision.
 
122
    return branch.get_revision_delta(revno)
 
123
 
 
124
 
86
125
def show_log(branch,
87
126
             lf,
88
127
             specific_fileid=None,
113
152
    end_revision
114
153
        If not None, only show revisions <= end_revision
115
154
    """
 
155
    branch.lock_read()
 
156
    try:
 
157
        _show_log(branch, lf, specific_fileid, verbose, direction,
 
158
                  start_revision, end_revision, search)
 
159
    finally:
 
160
        branch.unlock()
 
161
    
 
162
def _show_log(branch,
 
163
             lf,
 
164
             specific_fileid=None,
 
165
             verbose=False,
 
166
             direction='reverse',
 
167
             start_revision=None,
 
168
             end_revision=None,
 
169
             search=None):
 
170
    """Worker function for show_log - see show_log."""
116
171
    from bzrlib.osutils import format_date
117
172
    from bzrlib.errors import BzrCheckError
118
173
    from bzrlib.textui import show_status
123
178
        warn("not a LogFormatter instance: %r" % lf)
124
179
 
125
180
    if specific_fileid:
126
 
        mutter('get log for file_id %r' % specific_fileid)
 
181
        mutter('get log for file_id %r', specific_fileid)
127
182
 
128
183
    if search is not None:
129
184
        import re
131
186
    else:
132
187
        searchRE = None
133
188
 
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:
 
189
    which_revs = _enumerate_history(branch)
 
190
    
 
191
    if start_revision is None:
 
192
        start_revision = 1
 
193
    else:
 
194
        branch.check_real_revno(start_revision)
 
195
    
 
196
    if end_revision is None:
 
197
        end_revision = len(which_revs)
 
198
    else:
 
199
        branch.check_real_revno(end_revision)
 
200
 
 
201
    # list indexes are 0-based; revisions are 1-based
 
202
    cut_revs = which_revs[(start_revision-1):(end_revision)]
 
203
 
 
204
    if direction == 'reverse':
 
205
        cut_revs.reverse()
 
206
    elif direction == 'forward':
 
207
        pass
 
208
    else:
 
209
        raise ValueError('invalid direction %r' % direction)
 
210
 
 
211
    revision_history = branch.revision_history()
 
212
    for revno, rev_id in cut_revs:
 
213
        if verbose or specific_fileid:
 
214
            delta = _get_revision_delta(branch, revno)
 
215
            
148
216
        if specific_fileid:
149
217
            if not delta.touches_file_id(specific_fileid):
150
218
                continue
153
221
            # although we calculated it, throw it away without display
154
222
            delta = None
155
223
 
156
 
        if searchRE is None or searchRE.search(rev.message):
157
 
            lf.show(revno, rev, delta)
158
 
 
 
224
        rev = branch.get_revision(rev_id)
 
225
 
 
226
        if searchRE:
 
227
            if not searchRE.search(rev.message):
 
228
                continue
 
229
 
 
230
        lf.show(revno, rev, delta)
 
231
        if hasattr(lf, 'show_merge'):
 
232
            if revno == 1:
 
233
                excludes = set()
 
234
            else:
 
235
                # revno is 1 based, so -2 to get back 1 less.
 
236
                excludes = set(branch.get_ancestry(revision_history[revno - 2]))
 
237
            pending = list(rev.parent_ids)
 
238
            while pending:
 
239
                rev_id = pending.pop()
 
240
                if rev_id in excludes:
 
241
                    continue
 
242
                # prevent showing merged revs twice if they multi-path.
 
243
                excludes.add(rev_id)
 
244
                try:
 
245
                    rev = branch.get_revision(rev_id)
 
246
                except errors.NoSuchRevision:
 
247
                    continue
 
248
                pending.extend(rev.parent_ids)
 
249
                lf.show_merge(rev)
159
250
 
160
251
 
161
252
def deltas_for_log_dummy(branch, which_revs):
 
253
    """Return all the revisions without intermediate deltas.
 
254
 
 
255
    Useful for log commands that won't need the delta information.
 
256
    """
 
257
    
162
258
    for revno, revision_id in which_revs:
163
259
        yield revno, branch.get_revision(revision_id), None
164
260
 
165
261
 
166
262
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).
 
263
    """Compute deltas for display in latest-to-earliest order.
 
264
 
 
265
    branch
 
266
        Branch to traverse
 
267
 
 
268
    which_revs
 
269
        Sequence of (revno, revision_id) for the subset of history to examine
 
270
 
 
271
    returns 
 
272
        Sequence of (revno, rev, delta)
171
273
 
172
274
    The delta is from the given revision to the next one in the
173
275
    sequence, which makes sense if the log is being displayed from
174
276
    newest to oldest.
175
277
    """
176
 
    from tree import EmptyTree
177
 
    from diff import compare_trees
178
 
    
179
278
    last_revno = last_revision_id = last_tree = None
180
279
    for revno, revision_id in which_revs:
181
280
        this_tree = branch.revision_tree(revision_id)
210
309
    sequence, which makes sense if the log is being displayed from
211
310
    newest to oldest.
212
311
    """
213
 
    from tree import EmptyTree
214
 
    from diff import compare_trees
215
 
 
216
312
    last_revno = last_revision_id = last_tree = None
217
313
    prev_tree = EmptyTree(branch.get_root_id())
218
314
 
237
333
 
238
334
class LogFormatter(object):
239
335
    """Abstract class to display log messages."""
240
 
    def __init__(self, to_file, show_ids=False, show_timezone=False):
 
336
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
241
337
        self.to_file = to_file
242
338
        self.show_ids = show_ids
243
339
        self.show_timezone = show_timezone
244
 
        
245
 
 
246
 
 
247
 
 
248
 
 
249
 
 
 
340
 
 
341
 
 
342
    def show(self, revno, rev, delta):
 
343
        raise NotImplementedError('not implemented in abstract base')
 
344
 
 
345
    def short_committer(self, rev):
 
346
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
 
347
    
 
348
    
250
349
class LongLogFormatter(LogFormatter):
251
350
    def show(self, revno, rev, delta):
 
351
        return self._show_helper(revno=revno, rev=rev)
 
352
 
 
353
    def show_merge(self, rev):
 
354
        return self._show_helper(rev=rev, indent='    ', merged=True)
 
355
 
 
356
    def _show_helper(self, rev=None, revno=None, indent='', merged=False):
252
357
        from osutils import format_date
253
358
 
254
359
        to_file = self.to_file
255
360
 
256
 
        print >>to_file,  '-' * 60
257
 
        print >>to_file,  'revno:', revno
 
361
 
 
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))
263
 
 
264
 
        print >>to_file,  'message:'
 
370
            for parent_id in rev.parent_ids:
 
371
                print >>to_file, indent+'parent:', parent_id
 
372
            
 
373
        print >>to_file,  indent+'committer:', rev.committer
 
374
        try:
 
375
            print >>to_file, indent+'branch nick: %s' % \
 
376
                rev.properties['branch-nick']
 
377
        except KeyError:
 
378
            pass
 
379
 
 
380
        date_str = format_date(rev.timestamp,
 
381
                               rev.timezone or 0,
 
382
                               self.show_timezone)
 
383
        print >>to_file,  indent+'timestamp: %s' % date_str
 
384
 
 
385
        print >>to_file,  indent+'message:'
265
386
        if not rev.message:
266
 
            print >>to_file,  '  (no message)'
 
387
            print >>to_file,  indent+'  (no message)'
267
388
        else:
268
389
            for l in rev.message.split('\n'):
269
 
                print >>to_file,  '  ' + l
270
 
 
271
 
        if delta != None:
272
 
            delta.show(to_file, self.show_ids)
273
 
 
 
390
                print >>to_file,  indent+'  ' + l
274
391
 
275
392
 
276
393
class ShortLogFormatter(LogFormatter):
278
395
        from bzrlib.osutils import format_date
279
396
 
280
397
        to_file = self.to_file
281
 
 
282
 
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
 
398
        date_str = format_date(rev.timestamp, rev.timezone or 0,
 
399
                            self.show_timezone)
 
400
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
283
401
                format_date(rev.timestamp, rev.timezone or 0,
284
 
                            self.show_timezone))
 
402
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
403
                           show_offset=False))
285
404
        if self.show_ids:
286
405
            print >>to_file,  '      revision-id:', rev.revision_id
287
406
        if not rev.message:
290
409
            for l in rev.message.split('\n'):
291
410
                print >>to_file,  '      ' + l
292
411
 
 
412
        # TODO: Why not show the modified files in a shorter form as
 
413
        # well? rewrap them single lines of appropriate length
293
414
        if delta != None:
294
415
            delta.show(to_file, self.show_ids)
295
416
        print
296
417
 
297
 
 
 
418
class LineLogFormatter(LogFormatter):
 
419
    def truncate(self, str, max_len):
 
420
        if len(str) <= max_len:
 
421
            return str
 
422
        return str[:max_len-3]+'...'
 
423
 
 
424
    def date_string(self, rev):
 
425
        from bzrlib.osutils import format_date
 
426
        return format_date(rev.timestamp, rev.timezone or 0, 
 
427
                           self.show_timezone, date_fmt="%Y-%m-%d",
 
428
                           show_offset=False)
 
429
 
 
430
    def message(self, rev):
 
431
        if not rev.message:
 
432
            return '(no message)'
 
433
        else:
 
434
            return rev.message
 
435
 
 
436
    def show(self, revno, rev, delta):
 
437
        print >> self.to_file, self.log_string(rev, 79) 
 
438
 
 
439
    def log_string(self, rev, max_chars):
 
440
        out = [self.truncate(self.short_committer(rev), 20)]
 
441
        out.append(self.date_string(rev))
 
442
        out.append(self.message(rev).replace('\n', ' '))
 
443
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
444
 
 
445
def line_log(rev, max_chars):
 
446
    lf = LineLogFormatter(None)
 
447
    return lf.log_string(rev, max_chars)
298
448
 
299
449
FORMATTERS = {'long': LongLogFormatter,
300
450
              'short': ShortLogFormatter,
 
451
              'line': LineLogFormatter,
301
452
              }
302
453
 
303
454
 
304
455
def log_formatter(name, *args, **kwargs):
 
456
    """Construct a formatter from arguments.
 
457
 
 
458
    name -- Name of the formatter to construct; currently 'long', 'short' and
 
459
        'line' are supported.
 
460
    """
305
461
    from bzrlib.errors import BzrCommandError
306
 
    
307
462
    try:
308
463
        return FORMATTERS[name](*args, **kwargs)
309
464
    except IndexError:
310
465
        raise BzrCommandError("unknown log formatter: %r" % name)
 
466
 
 
467
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
468
    # deprecated; for compatability
 
469
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
470
    lf.show(revno, rev, delta)
 
471
 
 
472
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
 
473
    """Show the change in revision history comparing the old revision history to the new one.
 
474
 
 
475
    :param branch: The branch where the revisions exist
 
476
    :param old_rh: The old revision history
 
477
    :param new_rh: The new revision history
 
478
    :param to_file: A file to write the results to. If None, stdout will be used
 
479
    """
 
480
    if to_file is None:
 
481
        import sys
 
482
        import codecs
 
483
        import bzrlib
 
484
        to_file = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
485
    lf = log_formatter(log_format,
 
486
                       show_ids=False,
 
487
                       to_file=to_file,
 
488
                       show_timezone='original')
 
489
 
 
490
    # This is the first index which is different between
 
491
    # old and new
 
492
    base_idx = None
 
493
    for i in xrange(max(len(new_rh),
 
494
                        len(old_rh))):
 
495
        if (len(new_rh) <= i
 
496
            or len(old_rh) <= i
 
497
            or new_rh[i] != old_rh[i]):
 
498
            base_idx = i
 
499
            break
 
500
 
 
501
    if base_idx is None:
 
502
        to_file.write('Nothing seems to have changed\n')
 
503
        return
 
504
    ## TODO: It might be nice to do something like show_log
 
505
    ##       and show the merged entries. But since this is the
 
506
    ##       removed revisions, it shouldn't be as important
 
507
    if base_idx < len(old_rh):
 
508
        to_file.write('*'*60)
 
509
        to_file.write('\nRemoved Revisions:\n')
 
510
        for i in range(base_idx, len(old_rh)):
 
511
            rev = branch.get_revision(old_rh[i])
 
512
            lf.show(i+1, rev, None)
 
513
        to_file.write('*'*60)
 
514
        to_file.write('\n\n')
 
515
    if base_idx < len(new_rh):
 
516
        to_file.write('Added Revisions:\n')
 
517
        show_log(branch,
 
518
                 lf,
 
519
                 None,
 
520
                 verbose=True,
 
521
                 direction='forward',
 
522
                 start_revision=base_idx+1,
 
523
                 end_revision=len(new_rh),
 
524
                 search=None)
 
525