← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

[merge] from aaron

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
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
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
 
19
59
 
20
60
def find_touching_revisions(branch, file_id):
21
61
    """Yield a description of revisions which affect the file_id.
25
65
    This is the list of revisions where the file is either added,
26
66
    modified, renamed or deleted.
27
67
 
28
 
    Revisions are returned in chronological order.
29
 
 
30
68
    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.
 
69
    or to traverse a non-mainline set of revisions?
35
70
    """
36
71
    last_ie = None
37
72
    last_path = None
66
101
        revno += 1
67
102
 
68
103
 
 
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
 
69
125
def show_log(branch,
70
 
             filename=None,
71
 
             show_timezone='original',
 
126
             lf,
 
127
             specific_fileid=None,
72
128
             verbose=False,
73
 
             show_ids=False,
74
 
             to_file=None):
 
129
             direction='reverse',
 
130
             start_revision=None,
 
131
             end_revision=None,
 
132
             search=None):
75
133
    """Write out human-readable log of commits to this branch.
76
134
 
77
 
    filename
 
135
    lf
 
136
        LogFormatter object to show the output.
 
137
 
 
138
    specific_fileid
78
139
        If true, list only the commits affecting the specified
79
140
        file, rather than all commits.
80
141
 
81
 
    show_timezone
82
 
        'original' (committer's timezone),
83
 
        'utc' (universal time), or
84
 
        'local' (local user's timezone)
85
 
 
86
142
    verbose
87
143
        If true show added/changed/deleted/renamed files.
88
144
 
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:
102
 
        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
 
145
    direction
 
146
        'reverse' (default) is latest to earliest;
 
147
        'forward' is earliest to latest.
 
148
 
 
149
    start_revision
 
150
        If not None, only show revisions >= start_revision
 
151
 
 
152
    end_revision
 
153
        If not None, only show revisions <= end_revision
 
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."""
 
171
    from bzrlib.osutils import format_date
 
172
    from bzrlib.errors import BzrCheckError
 
173
    from bzrlib.textui import show_status
 
174
    
 
175
    from warnings import warn
 
176
 
 
177
    if not isinstance(lf, LogFormatter):
 
178
        warn("not a LogFormatter instance: %r" % lf)
 
179
 
 
180
    if specific_fileid:
 
181
        mutter('get log for file_id %r' % specific_fileid)
 
182
 
 
183
    if search is not None:
 
184
        import re
 
185
        searchRE = re.compile(search, re.IGNORECASE)
 
186
    else:
 
187
        searchRE = None
 
188
 
 
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
            
 
216
        if specific_fileid:
 
217
            if not delta.touches_file_id(specific_fileid):
 
218
                continue
 
219
 
 
220
        if not verbose:
 
221
            # although we calculated it, throw it away without display
 
222
            delta = None
 
223
 
 
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)
 
250
 
 
251
 
 
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
    
 
258
    for revno, revision_id in which_revs:
 
259
        yield revno, branch.get_revision(revision_id), None
 
260
 
 
261
 
 
262
def deltas_for_log_reverse(branch, which_revs):
 
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)
 
273
 
 
274
    The delta is from the given revision to the next one in the
 
275
    sequence, which makes sense if the log is being displayed from
 
276
    newest to oldest.
 
277
    """
 
278
    last_revno = last_revision_id = last_tree = None
 
279
    for revno, revision_id in which_revs:
 
280
        this_tree = branch.revision_tree(revision_id)
 
281
        this_revision = branch.get_revision(revision_id)
114
282
        
115
 
    branch._need_readlock()
116
 
    precursor = None
117
 
    if verbose:
118
 
        prev_inv = Inventory()
119
 
    for revno, revision_id in which_revs():
 
283
        if last_revno:
 
284
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
285
 
 
286
        this_tree = EmptyTree(branch.get_root_id())
 
287
 
 
288
        last_revno = revno
 
289
        last_revision = this_revision
 
290
        last_tree = this_tree
 
291
 
 
292
    if last_revno:
 
293
        if last_revno == 1:
 
294
            this_tree = EmptyTree(branch.get_root_id())
 
295
        else:
 
296
            this_revno = last_revno - 1
 
297
            this_revision_id = branch.revision_history()[this_revno]
 
298
            this_tree = branch.revision_tree(this_revision_id)
 
299
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
300
 
 
301
 
 
302
def deltas_for_log_forward(branch, which_revs):
 
303
    """Compute deltas for display in forward log.
 
304
 
 
305
    Given a sequence of (revno, revision_id) pairs, return
 
306
    (revno, rev, delta).
 
307
 
 
308
    The delta is from the given revision to the next one in the
 
309
    sequence, which makes sense if the log is being displayed from
 
310
    newest to oldest.
 
311
    """
 
312
    last_revno = last_revision_id = last_tree = None
 
313
    prev_tree = EmptyTree(branch.get_root_id())
 
314
 
 
315
    for revno, revision_id in which_revs:
 
316
        this_tree = branch.revision_tree(revision_id)
 
317
        this_revision = branch.get_revision(revision_id)
 
318
 
 
319
        if not last_revno:
 
320
            if revno == 1:
 
321
                last_tree = EmptyTree(branch.get_root_id())
 
322
            else:
 
323
                last_revno = revno - 1
 
324
                last_revision_id = branch.revision_history()[last_revno]
 
325
                last_tree = branch.revision_tree(last_revision_id)
 
326
 
 
327
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
328
 
 
329
        last_revno = revno
 
330
        last_revision = this_revision
 
331
        last_tree = this_tree
 
332
 
 
333
 
 
334
class LogFormatter(object):
 
335
    """Abstract class to display log messages."""
 
336
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
337
        self.to_file = to_file
 
338
        self.show_ids = show_ids
 
339
        self.show_timezone = show_timezone
 
340
 
 
341
 
 
342
    def show(self, revno, rev, delta):
 
343
        raise NotImplementedError('not implemented in abstract base')
 
344
 
 
345
    
 
346
class LongLogFormatter(LogFormatter):
 
347
    def show(self, revno, rev, delta):
 
348
        from osutils import format_date
 
349
 
 
350
        to_file = self.to_file
 
351
 
120
352
        print >>to_file,  '-' * 60
121
353
        print >>to_file,  'revno:', revno
122
 
        rev = branch.get_revision(revision_id)
123
 
        if show_ids:
124
 
            print >>to_file,  'revision-id:', revision_id
 
354
        if self.show_ids:
 
355
            print >>to_file,  'revision-id:', rev.revision_id
 
356
 
 
357
            for parent_id in rev.parent_ids:
 
358
                print >>to_file, 'parent:', parent_id
 
359
            
125
360
        print >>to_file,  'committer:', rev.committer
126
 
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
127
 
                                             show_timezone))
128
361
 
129
 
        if revision_id != rev.revision_id:
130
 
            raise BzrCheckError("retrieved wrong revision: %r"
131
 
                                % (revision_id, rev.revision_id))
 
362
        date_str = format_date(rev.timestamp,
 
363
                               rev.timezone or 0,
 
364
                               self.show_timezone)
 
365
        print >>to_file,  'timestamp: %s' % date_str
132
366
 
133
367
        print >>to_file,  'message:'
134
368
        if not rev.message:
137
371
            for l in rev.message.split('\n'):
138
372
                print >>to_file,  '  ' + l
139
373
 
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
179
 
 
 
374
        if delta != None:
 
375
            delta.show(to_file, self.show_ids)
 
376
 
 
377
    def show_merge(self, rev):
 
378
        from osutils import format_date
 
379
 
 
380
        to_file = self.to_file
 
381
 
 
382
        indent = '    '
 
383
 
 
384
        print >>to_file,  indent+'-' * 60
 
385
        print >>to_file,  indent+'merged:', rev.revision_id
 
386
        if self.show_ids:
 
387
            for parent_id in rev.parent_ids:
 
388
                print >>to_file, indent+'parent:', parent_id
 
389
            
 
390
        print >>to_file,  indent+'committer:', rev.committer
 
391
 
 
392
        date_str = format_date(rev.timestamp,
 
393
                               rev.timezone or 0,
 
394
                               self.show_timezone)
 
395
        print >>to_file,  indent+'timestamp: %s' % date_str
 
396
 
 
397
        print >>to_file,  indent+'message:'
 
398
        if not rev.message:
 
399
            print >>to_file,  indent+'  (no message)'
 
400
        else:
 
401
            for l in rev.message.split('\n'):
 
402
                print >>to_file,  indent+'  ' + l
 
403
 
 
404
 
 
405
class ShortLogFormatter(LogFormatter):
 
406
    def show(self, revno, rev, delta):
 
407
        from bzrlib.osutils import format_date
 
408
 
 
409
        to_file = self.to_file
 
410
        date_str = format_date(rev.timestamp, rev.timezone or 0,
 
411
                            self.show_timezone)
 
412
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
 
413
                format_date(rev.timestamp, rev.timezone or 0,
 
414
                            self.show_timezone))
 
415
        if self.show_ids:
 
416
            print >>to_file,  '      revision-id:', rev.revision_id
 
417
        if not rev.message:
 
418
            print >>to_file,  '      (no message)'
 
419
        else:
 
420
            for l in rev.message.split('\n'):
 
421
                print >>to_file,  '      ' + l
 
422
 
 
423
        # TODO: Why not show the modified files in a shorter form as
 
424
        # well? rewrap them single lines of appropriate length
 
425
        if delta != None:
 
426
            delta.show(to_file, self.show_ids)
 
427
        print
 
428
 
 
429
class LineLogFormatter(LogFormatter):
 
430
    def truncate(self, str, max_len):
 
431
        if len(str) <= max_len:
 
432
            return str
 
433
        return str[:max_len-3]+'...'
 
434
 
 
435
    def date_string(self, rev):
 
436
        from bzrlib.osutils import format_date
 
437
        return format_date(rev.timestamp, rev.timezone or 0, 
 
438
                           self.show_timezone, date_fmt="%Y-%m-%d",
 
439
                           show_offset=False)
 
440
 
 
441
    def message(self, rev):
 
442
        if not rev.message:
 
443
            return '(no message)'
 
444
        else:
 
445
            return rev.message
 
446
 
 
447
    def short_committer(self, rev):
 
448
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
 
449
    
 
450
    def show(self, revno, rev, delta):
 
451
        print >> self.to_file, self.log_string(rev, 79) 
 
452
 
 
453
    def log_string(self, rev, max_chars):
 
454
        out = [self.truncate(self.short_committer(rev), 20)]
 
455
        out.append(self.date_string(rev))
 
456
        out.append(self.message(rev).replace('\n', ' '))
 
457
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
458
 
 
459
def line_log(rev, max_chars):
 
460
    lf = LineLogFormatter(None)
 
461
    return lf.log_string(rev, max_chars)
 
462
 
 
463
FORMATTERS = {'long': LongLogFormatter,
 
464
              'short': ShortLogFormatter,
 
465
              'line': LineLogFormatter,
 
466
              }
 
467
 
 
468
 
 
469
def log_formatter(name, *args, **kwargs):
 
470
    """Construct a formatter from arguments.
 
471
 
 
472
    name -- Name of the formatter to construct; currently 'long', 'short' and
 
473
        'line' are supported.
 
474
    """
 
475
    from bzrlib.errors import BzrCommandError
 
476
    try:
 
477
        return FORMATTERS[name](*args, **kwargs)
 
478
    except IndexError:
 
479
        raise BzrCommandError("unknown log formatter: %r" % name)
 
480
 
 
481
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
482
    # deprecated; for compatability
 
483
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
484
    lf.show(revno, rev, delta)