← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Martin Pool
  • Date: 2005-05-10 06:00:59 UTC
  • Revision ID: mbp@sourcefrog.net-20050510060059-bae67a465325f650
- Use AtomicFile to update statcache.
- New closed property on AtomicFile

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