← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Robert Collins
  • Date: 2006-03-28 11:16:28 UTC
  • mto: (1626.2.1 integration)
  • mto: This revision was merged to the branch mainline in revision 1628.
  • Revision ID: robertc@robertcollins.net-20060328111628-47766b0fdfa443ab
Add MergeSort facility to bzrlib.tsort.

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.
53
74
    last_path = None
54
75
    revno = 1
55
76
    for revision_id in branch.revision_history():
56
 
        this_inv = branch.get_revision_inventory(revision_id)
 
77
        this_inv = branch.repository.get_revision_inventory(revision_id)
57
78
        if file_id in this_inv:
58
79
            this_ie = this_inv[file_id]
59
80
            this_path = this_inv.id2path(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,
 
128
             lf,
87
129
             specific_fileid=None,
88
 
             show_timezone='original',
89
130
             verbose=False,
90
 
             show_ids=False,
91
 
             to_file=None,
92
131
             direction='reverse',
93
132
             start_revision=None,
94
 
             end_revision=None):
 
133
             end_revision=None,
 
134
             search=None):
95
135
    """Write out human-readable log of commits to this branch.
96
136
 
 
137
    lf
 
138
        LogFormatter object to show the output.
 
139
 
97
140
    specific_fileid
98
141
        If true, list only the commits affecting the specified
99
142
        file, rather than all commits.
100
143
 
101
 
    show_timezone
102
 
        'original' (committer's timezone),
103
 
        'utc' (universal time), or
104
 
        'local' (local user's timezone)
105
 
 
106
144
    verbose
107
145
        If true show added/changed/deleted/renamed files.
108
146
 
109
 
    show_ids
110
 
        If true, show revision and file ids.
111
 
 
112
 
    to_file
113
 
        File to send log to; by default stdout.
114
 
 
115
147
    direction
116
148
        'reverse' (default) is latest to earliest;
117
149
        'forward' is earliest to latest.
122
154
    end_revision
123
155
        If not None, only show revisions <= end_revision
124
156
    """
125
 
    from osutils import format_date
126
 
    from errors import BzrCheckError
127
 
    from textui import show_status
 
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
    from bzrlib.osutils import format_date
 
174
    from bzrlib.errors import BzrCheckError
 
175
    from bzrlib.textui import show_status
 
176
    
 
177
    from warnings import warn
128
178
 
 
179
    if not isinstance(lf, LogFormatter):
 
180
        warn("not a LogFormatter instance: %r" % lf)
129
181
 
130
182
    if specific_fileid:
131
 
        mutter('get log for file_id %r' % specific_fileid)
132
 
 
133
 
    if to_file == None:
134
 
        import sys
135
 
        to_file = sys.stdout
136
 
 
137
 
    which_revs = branch.enum_history(direction)
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
 
        raise NotImplementedError("sorry, verbose forward logs not done yet")
146
 
 
147
 
    for revno, rev, delta in with_deltas:
 
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
            
148
218
        if specific_fileid:
149
219
            if not delta.touches_file_id(specific_fileid):
150
220
                continue
151
221
 
152
 
        if start_revision is not None and revno < start_revision:
153
 
            continue
154
 
 
155
 
        if end_revision is not None and revno > end_revision:
156
 
            continue
157
 
        
158
222
        if not verbose:
159
223
            # although we calculated it, throw it away without display
160
224
            delta = None
161
 
            
162
 
        show_one_log(revno, rev, delta, show_ids, to_file, show_timezone)
163
 
 
 
225
 
 
226
        rev = branch.repository.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
                repository = branch.repository
 
239
                excludes = repository.get_ancestry(revision_history[revno - 2])
 
240
                excludes = set(excludes)
 
241
            pending = list(rev.parent_ids)
 
242
            while pending:
 
243
                rev_id = pending.pop()
 
244
                if rev_id in excludes:
 
245
                    continue
 
246
                # prevent showing merged revs twice if they multi-path.
 
247
                excludes.add(rev_id)
 
248
                try:
 
249
                    rev = branch.repository.get_revision(rev_id)
 
250
                except errors.NoSuchRevision:
 
251
                    continue
 
252
                pending.extend(rev.parent_ids)
 
253
                lf.show_merge(rev)
164
254
 
165
255
 
166
256
def deltas_for_log_dummy(branch, which_revs):
 
257
    """Return all the revisions without intermediate deltas.
 
258
 
 
259
    Useful for log commands that won't need the delta information.
 
260
    """
 
261
    
167
262
    for revno, revision_id in which_revs:
168
263
        yield revno, branch.get_revision(revision_id), None
169
264
 
170
265
 
171
266
def deltas_for_log_reverse(branch, which_revs):
172
 
    """Compute deltas for display in reverse log.
173
 
 
174
 
    Given a sequence of (revno, revision_id) pairs, return
175
 
    (revno, rev, delta).
 
267
    """Compute deltas for display in latest-to-earliest order.
 
268
 
 
269
    branch
 
270
        Branch to traverse
 
271
 
 
272
    which_revs
 
273
        Sequence of (revno, revision_id) for the subset of history to examine
 
274
 
 
275
    returns 
 
276
        Sequence of (revno, rev, delta)
176
277
 
177
278
    The delta is from the given revision to the next one in the
178
279
    sequence, which makes sense if the log is being displayed from
179
280
    newest to oldest.
180
281
    """
181
 
    from tree import EmptyTree
182
 
    from diff import compare_trees
183
 
    
184
282
    last_revno = last_revision_id = last_tree = None
185
283
    for revno, revision_id in which_revs:
186
284
        this_tree = branch.revision_tree(revision_id)
189
287
        if last_revno:
190
288
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
191
289
 
 
290
        this_tree = EmptyTree(branch.get_root_id())
 
291
 
192
292
        last_revno = revno
193
293
        last_revision = this_revision
194
294
        last_tree = this_tree
195
295
 
196
296
    if last_revno:
197
 
        this_tree = EmptyTree()
 
297
        if last_revno == 1:
 
298
            this_tree = EmptyTree(branch.get_root_id())
 
299
        else:
 
300
            this_revno = last_revno - 1
 
301
            this_revision_id = branch.revision_history()[this_revno]
 
302
            this_tree = branch.revision_tree(this_revision_id)
198
303
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
199
304
 
200
305
 
201
 
 
202
 
 
203
 
def show_one_log(revno, rev, delta, show_ids, to_file, show_timezone):
204
 
    from osutils import format_date
205
 
    
206
 
    print >>to_file,  '-' * 60
207
 
    print >>to_file,  'revno:', revno
208
 
    if show_ids:
209
 
        print >>to_file,  'revision-id:', rev.revision_id
210
 
    print >>to_file,  'committer:', rev.committer
211
 
    print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
212
 
                                         show_timezone))
213
 
 
214
 
    print >>to_file,  'message:'
215
 
    if not rev.message:
216
 
        print >>to_file,  '  (no message)'
217
 
    else:
218
 
        for l in rev.message.split('\n'):
219
 
            print >>to_file,  '  ' + l
220
 
 
221
 
    if delta != None:
222
 
        delta.show(to_file, show_ids)
 
306
def deltas_for_log_forward(branch, which_revs):
 
307
    """Compute deltas for display in forward log.
 
308
 
 
309
    Given a sequence of (revno, revision_id) pairs, return
 
310
    (revno, rev, delta).
 
311
 
 
312
    The delta is from the given revision to the next one in the
 
313
    sequence, which makes sense if the log is being displayed from
 
314
    newest to oldest.
 
315
    """
 
316
    last_revno = last_revision_id = last_tree = None
 
317
    prev_tree = EmptyTree(branch.get_root_id())
 
318
 
 
319
    for revno, revision_id in which_revs:
 
320
        this_tree = branch.revision_tree(revision_id)
 
321
        this_revision = branch.get_revision(revision_id)
 
322
 
 
323
        if not last_revno:
 
324
            if revno == 1:
 
325
                last_tree = EmptyTree(branch.get_root_id())
 
326
            else:
 
327
                last_revno = revno - 1
 
328
                last_revision_id = branch.revision_history()[last_revno]
 
329
                last_tree = branch.revision_tree(last_revision_id)
 
330
 
 
331
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
332
 
 
333
        last_revno = revno
 
334
        last_revision = this_revision
 
335
        last_tree = this_tree
 
336
 
 
337
 
 
338
class LogFormatter(object):
 
339
    """Abstract class to display log messages."""
 
340
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
341
        self.to_file = to_file
 
342
        self.show_ids = show_ids
 
343
        self.show_timezone = show_timezone
 
344
 
 
345
 
 
346
    def show(self, revno, rev, delta):
 
347
        raise NotImplementedError('not implemented in abstract base')
 
348
 
 
349
    def short_committer(self, rev):
 
350
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
 
351
    
 
352
    
 
353
class LongLogFormatter(LogFormatter):
 
354
    def show(self, revno, rev, delta):
 
355
        return self._show_helper(revno=revno, rev=rev, delta=delta)
 
356
 
 
357
    def show_merge(self, rev):
 
358
        return self._show_helper(rev=rev, indent='    ', merged=True, delta=None)
 
359
 
 
360
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
 
361
        """Show a revision, either merged or not."""
 
362
        from bzrlib.osutils import format_date
 
363
        to_file = self.to_file
 
364
        print >>to_file,  indent+'-' * 60
 
365
        if revno is not None:
 
366
            print >>to_file,  'revno:', revno
 
367
        if merged:
 
368
            print >>to_file,  indent+'merged:', rev.revision_id
 
369
        elif self.show_ids:
 
370
            print >>to_file,  indent+'revision-id:', rev.revision_id
 
371
        if self.show_ids:
 
372
            for parent_id in rev.parent_ids:
 
373
                print >>to_file, indent+'parent:', parent_id
 
374
        print >>to_file,  indent+'committer:', rev.committer
 
375
        try:
 
376
            print >>to_file, indent+'branch nick: %s' % \
 
377
                rev.properties['branch-nick']
 
378
        except KeyError:
 
379
            pass
 
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:'
 
386
        if not rev.message:
 
387
            print >>to_file,  indent+'  (no message)'
 
388
        else:
 
389
            message = rev.message.rstrip('\r\n')
 
390
            for l in message.split('\n'):
 
391
                print >>to_file,  indent+'  ' + l
 
392
        if delta != None:
 
393
            delta.show(to_file, self.show_ids)
 
394
 
 
395
 
 
396
class ShortLogFormatter(LogFormatter):
 
397
    def show(self, revno, rev, delta):
 
398
        from bzrlib.osutils import format_date
 
399
 
 
400
        to_file = self.to_file
 
401
        date_str = format_date(rev.timestamp, rev.timezone or 0,
 
402
                            self.show_timezone)
 
403
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
 
404
                format_date(rev.timestamp, rev.timezone or 0,
 
405
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
406
                           show_offset=False))
 
407
        if self.show_ids:
 
408
            print >>to_file,  '      revision-id:', rev.revision_id
 
409
        if not rev.message:
 
410
            print >>to_file,  '      (no message)'
 
411
        else:
 
412
            message = rev.message.rstrip('\r\n')
 
413
            for l in message.split('\n'):
 
414
                print >>to_file,  '      ' + l
 
415
 
 
416
        # TODO: Why not show the modified files in a shorter form as
 
417
        # well? rewrap them single lines of appropriate length
 
418
        if delta != None:
 
419
            delta.show(to_file, self.show_ids)
 
420
        print >>to_file, ''
 
421
 
 
422
class LineLogFormatter(LogFormatter):
 
423
    def truncate(self, str, max_len):
 
424
        if len(str) <= max_len:
 
425
            return str
 
426
        return str[:max_len-3]+'...'
 
427
 
 
428
    def date_string(self, rev):
 
429
        from bzrlib.osutils import format_date
 
430
        return format_date(rev.timestamp, rev.timezone or 0, 
 
431
                           self.show_timezone, date_fmt="%Y-%m-%d",
 
432
                           show_offset=False)
 
433
 
 
434
    def message(self, rev):
 
435
        if not rev.message:
 
436
            return '(no message)'
 
437
        else:
 
438
            return rev.message
 
439
 
 
440
    def show(self, revno, rev, delta):
 
441
        print >> self.to_file, self.log_string(rev, 79) 
 
442
 
 
443
    def log_string(self, rev, max_chars):
 
444
        out = [self.truncate(self.short_committer(rev), 20)]
 
445
        out.append(self.date_string(rev))
 
446
        out.append(self.message(rev).replace('\n', ' '))
 
447
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
448
 
 
449
def line_log(rev, max_chars):
 
450
    lf = LineLogFormatter(None)
 
451
    return lf.log_string(rev, max_chars)
 
452
 
 
453
FORMATTERS = {
 
454
              'long': LongLogFormatter,
 
455
              'short': ShortLogFormatter,
 
456
              'line': LineLogFormatter,
 
457
              }
 
458
 
 
459
def register_formatter(name, formatter):
 
460
    FORMATTERS[name] = formatter
 
461
 
 
462
def log_formatter(name, *args, **kwargs):
 
463
    """Construct a formatter from arguments.
 
464
 
 
465
    name -- Name of the formatter to construct; currently 'long', 'short' and
 
466
        'line' are supported.
 
467
    """
 
468
    from bzrlib.errors import BzrCommandError
 
469
    try:
 
470
        return FORMATTERS[name](*args, **kwargs)
 
471
    except KeyError:
 
472
        raise BzrCommandError("unknown log formatter: %r" % name)
 
473
 
 
474
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
475
    # deprecated; for compatability
 
476
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
477
    lf.show(revno, rev, delta)
 
478
 
 
479
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
 
480
    """Show the change in revision history comparing the old revision history to the new one.
 
481
 
 
482
    :param branch: The branch where the revisions exist
 
483
    :param old_rh: The old revision history
 
484
    :param new_rh: The new revision history
 
485
    :param to_file: A file to write the results to. If None, stdout will be used
 
486
    """
 
487
    if to_file is None:
 
488
        import sys
 
489
        import codecs
 
490
        import bzrlib
 
491
        to_file = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
492
    lf = log_formatter(log_format,
 
493
                       show_ids=False,
 
494
                       to_file=to_file,
 
495
                       show_timezone='original')
 
496
 
 
497
    # This is the first index which is different between
 
498
    # old and new
 
499
    base_idx = None
 
500
    for i in xrange(max(len(new_rh),
 
501
                        len(old_rh))):
 
502
        if (len(new_rh) <= i
 
503
            or len(old_rh) <= i
 
504
            or new_rh[i] != old_rh[i]):
 
505
            base_idx = i
 
506
            break
 
507
 
 
508
    if base_idx is None:
 
509
        to_file.write('Nothing seems to have changed\n')
 
510
        return
 
511
    ## TODO: It might be nice to do something like show_log
 
512
    ##       and show the merged entries. But since this is the
 
513
    ##       removed revisions, it shouldn't be as important
 
514
    if base_idx < len(old_rh):
 
515
        to_file.write('*'*60)
 
516
        to_file.write('\nRemoved Revisions:\n')
 
517
        for i in range(base_idx, len(old_rh)):
 
518
            rev = branch.repository.get_revision(old_rh[i])
 
519
            lf.show(i+1, rev, None)
 
520
        to_file.write('*'*60)
 
521
        to_file.write('\n\n')
 
522
    if base_idx < len(new_rh):
 
523
        to_file.write('Added Revisions:\n')
 
524
        show_log(branch,
 
525
                 lf,
 
526
                 None,
 
527
                 verbose=True,
 
528
                 direction='forward',
 
529
                 start_revision=base_idx+1,
 
530
                 end_revision=len(new_rh),
 
531
                 search=None)
 
532