~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Robert Collins
  • Date: 2005-12-24 02:20:45 UTC
  • mto: (1185.50.57 bzr-jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1550.
  • Revision ID: robertc@robertcollins.net-20051224022045-14efc8dfa0e1a4e9
Start tests for api usage.

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
 
18
18
 
 
19
"""Code to show logs of changes.
 
20
 
 
21
Various flavors of log can be produced:
 
22
 
 
23
* for one file, or the whole tree, and (not done yet) for
 
24
  files in a given directory
 
25
 
 
26
* in "verbose" mode with a description of what changed from one
 
27
  version to the next
 
28
 
 
29
* with file-ids and revision-ids shown
 
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.
 
50
"""
 
51
 
 
52
 
 
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
 
19
61
 
20
62
def find_touching_revisions(branch, file_id):
21
63
    """Yield a description of revisions which affect the file_id.
25
67
    This is the list of revisions where the file is either added,
26
68
    modified, renamed or deleted.
27
69
 
28
 
    Revisions are returned in chronological order.
29
 
 
30
70
    TODO: Perhaps some way to limit this to only particular revisions,
31
 
    or to traverse a non-branch set of revisions?
32
 
 
33
 
    TODO: If a directory is given, then by default look for all
34
 
    changes under that directory.
 
71
    or to traverse a non-mainline set of revisions?
35
72
    """
36
73
    last_ie = None
37
74
    last_path = None
66
103
        revno += 1
67
104
 
68
105
 
 
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
 
69
127
def show_log(branch,
70
 
             filename=None,
71
 
             show_timezone='original',
 
128
             lf,
 
129
             specific_fileid=None,
72
130
             verbose=False,
73
 
             show_ids=False,
74
 
             to_file=None):
 
131
             direction='reverse',
 
132
             start_revision=None,
 
133
             end_revision=None,
 
134
             search=None):
75
135
    """Write out human-readable log of commits to this branch.
76
136
 
77
 
    filename
 
137
    lf
 
138
        LogFormatter object to show the output.
 
139
 
 
140
    specific_fileid
78
141
        If true, list only the commits affecting the specified
79
142
        file, rather than all commits.
80
143
 
81
 
    show_timezone
82
 
        'original' (committer's timezone),
83
 
        'utc' (universal time), or
84
 
        'local' (local user's timezone)
85
 
 
86
144
    verbose
87
145
        If true show added/changed/deleted/renamed files.
88
146
 
89
 
    show_ids
90
 
        If true, show revision and file ids.
91
 
 
92
 
    to_file
93
 
        File to send log to; by default stdout.
94
 
    """
95
 
    from osutils import format_date
96
 
    from errors import BzrCheckError
97
 
    from diff import compare_inventories
98
 
    from textui import show_status
99
 
    from inventory import Inventory
100
 
 
101
 
    if to_file == None:
 
147
    direction
 
148
        'reverse' (default) is latest to earliest;
 
149
        'forward' is earliest to latest.
 
150
 
 
151
    start_revision
 
152
        If not None, only show revisions >= start_revision
 
153
 
 
154
    end_revision
 
155
        If not None, only show revisions <= end_revision
 
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."""
 
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
 
178
 
 
179
    if not isinstance(lf, LogFormatter):
 
180
        warn("not a LogFormatter instance: %r" % lf)
 
181
 
 
182
    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
            
 
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)
 
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)
 
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
    """
 
259
    
 
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
 
334
 
 
335
 
 
336
class LogFormatter(object):
 
337
    """Abstract class to display log messages."""
 
338
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
339
        self.to_file = to_file
 
340
        self.show_ids = show_ids
 
341
        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
    
 
351
class LongLogFormatter(LogFormatter):
 
352
    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
 
361
        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
 
369
        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
 
382
 
 
383
        print >>to_file,  indent+'message:'
 
384
        if not rev.message:
 
385
            print >>to_file,  indent+'  (no message)'
 
386
        else:
 
387
            message = rev.message.rstrip('\r\n')
 
388
            for l in message.split('\n'):
 
389
                print >>to_file,  indent+'  ' + l
 
390
        if delta != None:
 
391
            delta.show(to_file, self.show_ids)
 
392
 
 
393
 
 
394
class ShortLogFormatter(LogFormatter):
 
395
    def show(self, revno, rev, delta):
 
396
        from bzrlib.osutils import format_date
 
397
 
 
398
        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),
 
402
                format_date(rev.timestamp, rev.timezone or 0,
 
403
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
404
                           show_offset=False))
 
405
        if self.show_ids:
 
406
            print >>to_file,  '      revision-id:', rev.revision_id
 
407
        if not rev.message:
 
408
            print >>to_file,  '      (no message)'
 
409
        else:
 
410
            message = rev.message.rstrip('\r\n')
 
411
            for l in message.split('\n'):
 
412
                print >>to_file,  '      ' + l
 
413
 
 
414
        # TODO: Why not show the modified files in a shorter form as
 
415
        # well? rewrap them single lines of appropriate length
 
416
        if delta != None:
 
417
            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)
 
450
 
 
451
FORMATTERS = {'long': LongLogFormatter,
 
452
              'short': ShortLogFormatter,
 
453
              'line': LineLogFormatter,
 
454
              }
 
455
 
 
456
 
 
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
    """
 
463
    from bzrlib.errors import BzrCommandError
 
464
    try:
 
465
        return FORMATTERS[name](*args, **kwargs)
 
466
    except IndexError:
 
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:
102
483
        import sys
103
 
        to_file = sys.stdout
104
 
 
105
 
    if filename:
106
 
        file_id = branch.read_working_inventory().path2id(filename)
107
 
        def which_revs():
108
 
            for revno, revid, why in find_touching_revisions(branch, file_id):
109
 
                yield revno, revid
110
 
    else:
111
 
        def which_revs():
112
 
            for i, revid in enumerate(branch.revision_history()):
113
 
                yield i+1, revid
114
 
        
115
 
    branch._need_readlock()
116
 
    precursor = None
117
 
    if verbose:
118
 
        prev_inv = Inventory()
119
 
    for revno, revision_id in which_revs():
120
 
        print >>to_file,  '-' * 60
121
 
        print >>to_file,  'revno:', revno
122
 
        rev = branch.get_revision(revision_id)
123
 
        if show_ids:
124
 
            print >>to_file,  'revision-id:', revision_id
125
 
        print >>to_file,  'committer:', rev.committer
126
 
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
127
 
                                             show_timezone))
128
 
 
129
 
        if revision_id != rev.revision_id:
130
 
            raise BzrCheckError("retrieved wrong revision: %r"
131
 
                                % (revision_id, rev.revision_id))
132
 
 
133
 
        print >>to_file,  'message:'
134
 
        if not rev.message:
135
 
            print >>to_file,  '  (no message)'
136
 
        else:
137
 
            for l in rev.message.split('\n'):
138
 
                print >>to_file,  '  ' + l
139
 
 
140
 
        # Don't show a list of changed files if we were asked about
141
 
        # one specific file.
142
 
 
143
 
        if verbose and not filename:
144
 
            this_inv = branch.get_inventory(rev.inventory_id)
145
 
            delta = compare_inventories(prev_inv, this_inv)
146
 
 
147
 
            if delta.removed:
148
 
                print >>to_file, 'removed files:'
149
 
                for path, fid in delta.removed:
150
 
                    if show_ids:
151
 
                        print >>to_file, '  %-30s %s' % (path, fid)
152
 
                    else:
153
 
                        print >>to_file, ' ', path
154
 
            if delta.added:
155
 
                print >>to_file, 'added files:'
156
 
                for path, fid in delta.added:
157
 
                    if show_ids:
158
 
                        print >>to_file, '  %-30s %s' % (path, fid)
159
 
                    else:
160
 
                        print >>to_file, '  ' + path
161
 
            if delta.renamed:
162
 
                print >>to_file, 'renamed files:'
163
 
                for oldpath, newpath, fid in delta.renamed:
164
 
                    if show_ids:
165
 
                        print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
166
 
                    else:
167
 
                        print >>to_file, '  %s => %s' % (oldpath, newpath)
168
 
            if delta.modified:
169
 
                print >>to_file, 'modified files:'
170
 
                for path, fid in delta.modified:
171
 
                    if show_ids:
172
 
                        print >>to_file, '  %-30s %s' % (path, fid)
173
 
                    else:
174
 
                        print >>to_file, '  ' + path
175
 
 
176
 
            prev_inv = this_inv
177
 
 
178
 
        precursor = revision_id
 
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)
179
527