~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Martin Pool
  • Date: 2005-07-05 08:09:30 UTC
  • Revision ID: mbp@sourcefrog.net-20050705080929-f44361a66a8b2e29
- Merge3.find_sync_regions always returns a zero-length sentinal at the end to
  ease matching.

- Merge3.merge partially done.

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
 
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.
 
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
50
36
"""
51
37
 
52
38
 
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
 
 
 
39
from trace import mutter
61
40
 
62
41
def find_touching_revisions(branch, file_id):
63
42
    """Yield a description of revisions which affect the file_id.
104
83
 
105
84
 
106
85
 
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
 
 
127
86
def show_log(branch,
128
87
             lf,
129
88
             specific_fileid=None,
130
89
             verbose=False,
131
90
             direction='reverse',
132
91
             start_revision=None,
133
 
             end_revision=None,
134
 
             search=None):
 
92
             end_revision=None):
135
93
    """Write out human-readable log of commits to this branch.
136
94
 
137
95
    lf
154
112
    end_revision
155
113
        If not None, only show revisions <= end_revision
156
114
    """
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."""
173
115
    from bzrlib.osutils import format_date
174
116
    from bzrlib.errors import BzrCheckError
175
117
    from bzrlib.textui import show_status
180
122
        warn("not a LogFormatter instance: %r" % lf)
181
123
 
182
124
    if specific_fileid:
183
 
        mutter('get log for file_id %r', specific_fileid)
184
 
 
185
 
    if search is not None:
186
 
        import re
187
 
        searchRE = re.compile(search, re.IGNORECASE)
188
 
    else:
189
 
        searchRE = None
190
 
 
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
 
            
 
125
        mutter('get log for file_id %r' % specific_fileid)
 
126
 
 
127
    which_revs = branch.enum_history(direction)
 
128
    which_revs = [x for x in which_revs if (
 
129
            (start_revision is None or x[0] >= start_revision)
 
130
            and (end_revision is None or x[0] <= end_revision))]
 
131
 
 
132
    if not (verbose or specific_fileid):
 
133
        # no need to know what changed between revisions
 
134
        with_deltas = deltas_for_log_dummy(branch, which_revs)
 
135
    elif direction == 'reverse':
 
136
        with_deltas = deltas_for_log_reverse(branch, which_revs)
 
137
    else:        
 
138
        with_deltas = deltas_for_log_forward(branch, which_revs)
 
139
 
 
140
    for revno, rev, delta in with_deltas:
218
141
        if specific_fileid:
219
142
            if not delta.touches_file_id(specific_fileid):
220
143
                continue
223
146
            # although we calculated it, throw it away without display
224
147
            delta = None
225
148
 
226
 
        rev = branch.get_revision(rev_id)
227
 
 
228
 
        if searchRE:
229
 
            if not searchRE.search(rev.message):
230
 
                continue
231
 
 
232
149
        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)
 
150
 
252
151
 
253
152
 
254
153
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
 
    
260
154
    for revno, revision_id in which_revs:
261
155
        yield revno, branch.get_revision(revision_id), None
262
156
 
263
157
 
264
158
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)
 
159
    """Compute deltas for display in reverse log.
 
160
 
 
161
    Given a sequence of (revno, revision_id) pairs, return
 
162
    (revno, rev, delta).
275
163
 
276
164
    The delta is from the given revision to the next one in the
277
165
    sequence, which makes sense if the log is being displayed from
278
166
    newest to oldest.
279
167
    """
 
168
    from tree import EmptyTree
 
169
    from diff import compare_trees
 
170
    
280
171
    last_revno = last_revision_id = last_tree = None
281
172
    for revno, revision_id in which_revs:
282
173
        this_tree = branch.revision_tree(revision_id)
285
176
        if last_revno:
286
177
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
287
178
 
288
 
        this_tree = EmptyTree(branch.get_root_id())
289
 
 
290
179
        last_revno = revno
291
180
        last_revision = this_revision
292
181
        last_tree = this_tree
293
182
 
294
183
    if last_revno:
295
184
        if last_revno == 1:
296
 
            this_tree = EmptyTree(branch.get_root_id())
 
185
            this_tree = EmptyTree()
297
186
        else:
298
187
            this_revno = last_revno - 1
299
188
            this_revision_id = branch.revision_history()[this_revno]
311
200
    sequence, which makes sense if the log is being displayed from
312
201
    newest to oldest.
313
202
    """
 
203
    from tree import EmptyTree
 
204
    from diff import compare_trees
 
205
 
314
206
    last_revno = last_revision_id = last_tree = None
315
 
    prev_tree = EmptyTree(branch.get_root_id())
316
 
 
317
207
    for revno, revision_id in which_revs:
318
208
        this_tree = branch.revision_tree(revision_id)
319
209
        this_revision = branch.get_revision(revision_id)
320
210
 
321
211
        if not last_revno:
322
212
            if revno == 1:
323
 
                last_tree = EmptyTree(branch.get_root_id())
 
213
                last_tree = EmptyTree()
324
214
            else:
325
215
                last_revno = revno - 1
326
216
                last_revision_id = branch.revision_history()[last_revno]
335
225
 
336
226
class LogFormatter(object):
337
227
    """Abstract class to display log messages."""
338
 
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
228
    def __init__(self, to_file, show_ids=False, show_timezone=False):
339
229
        self.to_file = to_file
340
230
        self.show_ids = show_ids
341
231
        self.show_timezone = show_timezone
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
 
    
 
232
        
 
233
 
 
234
 
 
235
 
 
236
 
 
237
 
351
238
class LongLogFormatter(LogFormatter):
352
239
    def show(self, revno, rev, delta):
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
 
240
        from osutils import format_date
 
241
 
361
242
        to_file = self.to_file
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
 
243
 
 
244
        print >>to_file,  '-' * 60
 
245
        print >>to_file,  'revno:', revno
369
246
        if self.show_ids:
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
 
247
            print >>to_file,  'revision-id:', rev.revision_id
 
248
        print >>to_file,  'committer:', rev.committer
 
249
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
 
250
                                             self.show_timezone))
382
251
 
383
 
        print >>to_file,  indent+'message:'
 
252
        print >>to_file,  'message:'
384
253
        if not rev.message:
385
 
            print >>to_file,  indent+'  (no message)'
 
254
            print >>to_file,  '  (no message)'
386
255
        else:
387
 
            message = rev.message.rstrip('\r\n')
388
 
            for l in message.split('\n'):
389
 
                print >>to_file,  indent+'  ' + l
 
256
            for l in rev.message.split('\n'):
 
257
                print >>to_file,  '  ' + l
 
258
 
390
259
        if delta != None:
391
260
            delta.show(to_file, self.show_ids)
392
261
 
393
262
 
 
263
 
394
264
class ShortLogFormatter(LogFormatter):
395
265
    def show(self, revno, rev, delta):
396
266
        from bzrlib.osutils import format_date
397
267
 
398
268
        to_file = self.to_file
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),
 
269
 
 
270
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
402
271
                format_date(rev.timestamp, rev.timezone or 0,
403
 
                            self.show_timezone, date_fmt="%Y-%m-%d",
404
 
                           show_offset=False))
 
272
                            self.show_timezone))
405
273
        if self.show_ids:
406
274
            print >>to_file,  '      revision-id:', rev.revision_id
407
275
        if not rev.message:
408
276
            print >>to_file,  '      (no message)'
409
277
        else:
410
 
            message = rev.message.rstrip('\r\n')
411
 
            for l in message.split('\n'):
 
278
            for l in rev.message.split('\n'):
412
279
                print >>to_file,  '      ' + l
413
280
 
414
 
        # TODO: Why not show the modified files in a shorter form as
415
 
        # well? rewrap them single lines of appropriate length
416
281
        if delta != None:
417
282
            delta.show(to_file, self.show_ids)
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)
 
283
        print
 
284
 
 
285
 
450
286
 
451
287
FORMATTERS = {'long': LongLogFormatter,
452
288
              'short': ShortLogFormatter,
453
 
              'line': LineLogFormatter,
454
289
              }
455
290
 
456
291
 
457
292
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
 
    """
463
293
    from bzrlib.errors import BzrCommandError
 
294
    
464
295
    try:
465
296
        return FORMATTERS[name](*args, **kwargs)
466
297
    except IndexError:
467
298
        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