← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

- stub for revision properties

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
 
19
58
 
20
59
def find_touching_revisions(branch, file_id):
21
60
    """Yield a description of revisions which affect the file_id.
25
64
    This is the list of revisions where the file is either added,
26
65
    modified, renamed or deleted.
27
66
 
28
 
    Revisions are returned in chronological order.
29
 
 
30
67
    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.
 
68
    or to traverse a non-mainline set of revisions?
35
69
    """
36
70
    last_ie = None
37
71
    last_path = None
66
100
        revno += 1
67
101
 
68
102
 
 
103
 
 
104
def _enumerate_history(branch):
 
105
    rh = []
 
106
    revno = 1
 
107
    for rev_id in branch.revision_history():
 
108
        rh.append((revno, rev_id))
 
109
        revno += 1
 
110
    return rh
 
111
 
 
112
 
 
113
def _get_revision_delta(branch, revno):
 
114
    """Return the delta for a mainline revision.
 
115
    
 
116
    This is used to show summaries in verbose logs, and also for finding 
 
117
    revisions which touch a given file."""
 
118
    # XXX: What are we supposed to do when showing a summary for something 
 
119
    # other than a mainline revision.  The delta to it's first parent, or
 
120
    # (more useful) the delta to a nominated other revision.
 
121
    return branch.get_revision_delta(revno)
 
122
 
 
123
 
69
124
def show_log(branch,
70
 
             filename=None,
71
 
             show_timezone='original',
 
125
             lf,
 
126
             specific_fileid=None,
72
127
             verbose=False,
73
 
             show_ids=False,
74
 
             to_file=None):
 
128
             direction='reverse',
 
129
             start_revision=None,
 
130
             end_revision=None,
 
131
             search=None):
75
132
    """Write out human-readable log of commits to this branch.
76
133
 
77
 
    filename
 
134
    lf
 
135
        LogFormatter object to show the output.
 
136
 
 
137
    specific_fileid
78
138
        If true, list only the commits affecting the specified
79
139
        file, rather than all commits.
80
140
 
81
 
    show_timezone
82
 
        'original' (committer's timezone),
83
 
        'utc' (universal time), or
84
 
        'local' (local user's timezone)
85
 
 
86
141
    verbose
87
142
        If true show added/changed/deleted/renamed files.
88
143
 
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
 
144
    direction
 
145
        'reverse' (default) is latest to earliest;
 
146
        'forward' is earliest to latest.
 
147
 
 
148
    start_revision
 
149
        If not None, only show revisions >= start_revision
 
150
 
 
151
    end_revision
 
152
        If not None, only show revisions <= end_revision
 
153
    """
 
154
    branch.lock_read()
 
155
    try:
 
156
        _show_log(branch, lf, specific_fileid, verbose, direction,
 
157
                  start_revision, end_revision, search)
 
158
    finally:
 
159
        branch.unlock()
 
160
    
 
161
def _show_log(branch,
 
162
             lf,
 
163
             specific_fileid=None,
 
164
             verbose=False,
 
165
             direction='reverse',
 
166
             start_revision=None,
 
167
             end_revision=None,
 
168
             search=None):
 
169
    """Worker function for show_log - see show_log."""
 
170
    from bzrlib.osutils import format_date
 
171
    from bzrlib.errors import BzrCheckError
 
172
    from bzrlib.textui import show_status
 
173
    
 
174
    from warnings import warn
 
175
 
 
176
    if not isinstance(lf, LogFormatter):
 
177
        warn("not a LogFormatter instance: %r" % lf)
 
178
 
 
179
    if specific_fileid:
 
180
        mutter('get log for file_id %r' % specific_fileid)
 
181
 
 
182
    if search is not None:
 
183
        import re
 
184
        searchRE = re.compile(search, re.IGNORECASE)
 
185
    else:
 
186
        searchRE = None
 
187
 
 
188
    which_revs = _enumerate_history(branch)
 
189
    
 
190
    if start_revision is None:
 
191
        start_revision = 1
 
192
    else:
 
193
        branch.check_real_revno(start_revision)
 
194
    
 
195
    if end_revision is None:
 
196
        end_revision = len(which_revs)
 
197
    else:
 
198
        branch.check_real_revno(end_revision)
 
199
 
 
200
    # list indexes are 0-based; revisions are 1-based
 
201
    cut_revs = which_revs[(start_revision-1):(end_revision)]
 
202
 
 
203
    if direction == 'reverse':
 
204
        cut_revs.reverse()
 
205
    elif direction == 'forward':
 
206
        pass
 
207
    else:
 
208
        raise ValueError('invalid direction %r' % direction)
 
209
 
 
210
    revision_history = branch.revision_history()
 
211
    for revno, rev_id in cut_revs:
 
212
        if verbose or specific_fileid:
 
213
            delta = _get_revision_delta(branch, revno)
 
214
            
 
215
        if specific_fileid:
 
216
            if not delta.touches_file_id(specific_fileid):
 
217
                continue
 
218
 
 
219
        if not verbose:
 
220
            # although we calculated it, throw it away without display
 
221
            delta = None
 
222
 
 
223
        rev = branch.get_revision(rev_id)
 
224
 
 
225
        if searchRE:
 
226
            if not searchRE.search(rev.message):
 
227
                continue
 
228
 
 
229
        lf.show(revno, rev, delta)
 
230
        if revno == 1:
 
231
            excludes = set()
 
232
        else:
 
233
            # revno is 1 based, so -2 to get back 1 less.
 
234
            excludes = set(branch.get_ancestry(revision_history[revno - 2]))
 
235
        pending = list(rev.parent_ids)
 
236
        while pending:
 
237
            rev_id = pending.pop()
 
238
            if rev_id in excludes:
 
239
                continue
 
240
            # prevent showing merged revs twice if they multi-path.
 
241
            excludes.add(rev_id)
 
242
            try:
 
243
                rev = branch.get_revision(rev_id)
 
244
            except errors.NoSuchRevision:
 
245
                continue
 
246
            pending.extend(rev.parent_ids)
 
247
            lf.show_merge(rev)
 
248
 
 
249
 
 
250
def deltas_for_log_dummy(branch, which_revs):
 
251
    """Return all the revisions without intermediate deltas.
 
252
 
 
253
    Useful for log commands that won't need the delta information.
 
254
    """
 
255
    
 
256
    for revno, revision_id in which_revs:
 
257
        yield revno, branch.get_revision(revision_id), None
 
258
 
 
259
 
 
260
def deltas_for_log_reverse(branch, which_revs):
 
261
    """Compute deltas for display in latest-to-earliest order.
 
262
 
 
263
    branch
 
264
        Branch to traverse
 
265
 
 
266
    which_revs
 
267
        Sequence of (revno, revision_id) for the subset of history to examine
 
268
 
 
269
    returns 
 
270
        Sequence of (revno, rev, delta)
 
271
 
 
272
    The delta is from the given revision to the next one in the
 
273
    sequence, which makes sense if the log is being displayed from
 
274
    newest to oldest.
 
275
    """
 
276
    last_revno = last_revision_id = last_tree = None
 
277
    for revno, revision_id in which_revs:
 
278
        this_tree = branch.revision_tree(revision_id)
 
279
        this_revision = branch.get_revision(revision_id)
114
280
        
115
 
    branch._need_readlock()
116
 
    precursor = None
117
 
    if verbose:
118
 
        prev_inv = Inventory()
119
 
    for revno, revision_id in which_revs():
 
281
        if last_revno:
 
282
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
283
 
 
284
        this_tree = EmptyTree(branch.get_root_id())
 
285
 
 
286
        last_revno = revno
 
287
        last_revision = this_revision
 
288
        last_tree = this_tree
 
289
 
 
290
    if last_revno:
 
291
        if last_revno == 1:
 
292
            this_tree = EmptyTree(branch.get_root_id())
 
293
        else:
 
294
            this_revno = last_revno - 1
 
295
            this_revision_id = branch.revision_history()[this_revno]
 
296
            this_tree = branch.revision_tree(this_revision_id)
 
297
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
298
 
 
299
 
 
300
def deltas_for_log_forward(branch, which_revs):
 
301
    """Compute deltas for display in forward log.
 
302
 
 
303
    Given a sequence of (revno, revision_id) pairs, return
 
304
    (revno, rev, delta).
 
305
 
 
306
    The delta is from the given revision to the next one in the
 
307
    sequence, which makes sense if the log is being displayed from
 
308
    newest to oldest.
 
309
    """
 
310
    last_revno = last_revision_id = last_tree = None
 
311
    prev_tree = EmptyTree(branch.get_root_id())
 
312
 
 
313
    for revno, revision_id in which_revs:
 
314
        this_tree = branch.revision_tree(revision_id)
 
315
        this_revision = branch.get_revision(revision_id)
 
316
 
 
317
        if not last_revno:
 
318
            if revno == 1:
 
319
                last_tree = EmptyTree(branch.get_root_id())
 
320
            else:
 
321
                last_revno = revno - 1
 
322
                last_revision_id = branch.revision_history()[last_revno]
 
323
                last_tree = branch.revision_tree(last_revision_id)
 
324
 
 
325
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
326
 
 
327
        last_revno = revno
 
328
        last_revision = this_revision
 
329
        last_tree = this_tree
 
330
 
 
331
 
 
332
class LogFormatter(object):
 
333
    """Abstract class to display log messages."""
 
334
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
335
        self.to_file = to_file
 
336
        self.show_ids = show_ids
 
337
        self.show_timezone = show_timezone
 
338
 
 
339
 
 
340
    def show(self, revno, rev, delta):
 
341
        raise NotImplementedError('not implemented in abstract base')
 
342
 
 
343
    def show_merge(self, rev):
 
344
        pass
 
345
 
 
346
    
 
347
class LongLogFormatter(LogFormatter):
 
348
    def show(self, revno, rev, delta):
 
349
        from osutils import format_date
 
350
 
 
351
        to_file = self.to_file
 
352
 
120
353
        print >>to_file,  '-' * 60
121
354
        print >>to_file,  'revno:', revno
122
 
        rev = branch.get_revision(revision_id)
123
 
        if show_ids:
124
 
            print >>to_file,  'revision-id:', revision_id
 
355
        if self.show_ids:
 
356
            print >>to_file,  'revision-id:', rev.revision_id
 
357
 
 
358
            for parent_id in rev.parent_ids:
 
359
                print >>to_file, 'parent:', parent_id
 
360
            
125
361
        print >>to_file,  'committer:', rev.committer
126
 
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
127
 
                                             show_timezone))
128
362
 
129
 
        if revision_id != rev.revision_id:
130
 
            raise BzrCheckError("retrieved wrong revision: %r"
131
 
                                % (revision_id, rev.revision_id))
 
363
        date_str = format_date(rev.timestamp,
 
364
                               rev.timezone or 0,
 
365
                               self.show_timezone)
 
366
        print >>to_file,  'timestamp: %s' % date_str
132
367
 
133
368
        print >>to_file,  'message:'
134
369
        if not rev.message:
137
372
            for l in rev.message.split('\n'):
138
373
                print >>to_file,  '  ' + l
139
374
 
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
 
 
 
375
        if delta != None:
 
376
            delta.show(to_file, self.show_ids)
 
377
 
 
378
    def show_merge(self, rev):
 
379
        from osutils import format_date
 
380
 
 
381
        to_file = self.to_file
 
382
 
 
383
        indent = '    '
 
384
 
 
385
        print >>to_file,  indent+'-' * 60
 
386
        print >>to_file,  indent+'merged:', rev.revision_id
 
387
        if self.show_ids:
 
388
            for parent_id in rev.parent_ids:
 
389
                print >>to_file, indent+'parent:', parent_id
 
390
            
 
391
        print >>to_file,  indent+'committer:', rev.committer
 
392
 
 
393
        date_str = format_date(rev.timestamp,
 
394
                               rev.timezone or 0,
 
395
                               self.show_timezone)
 
396
        print >>to_file,  indent+'timestamp: %s' % date_str
 
397
 
 
398
        print >>to_file,  indent+'message:'
 
399
        if not rev.message:
 
400
            print >>to_file,  indent+'  (no message)'
 
401
        else:
 
402
            for l in rev.message.split('\n'):
 
403
                print >>to_file,  indent+'  ' + l
 
404
 
 
405
 
 
406
class ShortLogFormatter(LogFormatter):
 
407
    def show(self, revno, rev, delta):
 
408
        from bzrlib.osutils import format_date
 
409
 
 
410
        to_file = self.to_file
 
411
 
 
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
 
 
430
 
 
431
FORMATTERS = {'long': LongLogFormatter,
 
432
              'short': ShortLogFormatter,
 
433
              }
 
434
 
 
435
 
 
436
def log_formatter(name, *args, **kwargs):
 
437
    """Construct a formatter from arguments.
 
438
 
 
439
    name -- Name of the formatter to construct; currently 'long' and
 
440
        'short' are supported.
 
441
    """
 
442
    from bzrlib.errors import BzrCommandError
 
443
    try:
 
444
        return FORMATTERS[name](*args, **kwargs)
 
445
    except IndexError:
 
446
        raise BzrCommandError("unknown log formatter: %r" % name)
 
447
 
 
448
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
449
    # deprecated; for compatability
 
450
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
451
    lf.show(revno, rev, delta)