~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Martin Pool
  • Date: 2005-06-06 04:47:33 UTC
  • Revision ID: mbp@sourcefrog.net-20050606044733-e902b05ac1747cd2
- fix invocation of testbzr when giving explicit bzr location

Show diffs side-by-side

added added

removed removed

Lines of Context:
28
28
 
29
29
* with file-ids and revision-ids shown
30
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.
 
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
50
36
"""
51
37
 
52
38
 
53
 
from bzrlib.tree import EmptyTree
54
 
from bzrlib.delta import compare_trees
55
 
from bzrlib.trace import mutter
56
 
from bzrlib.errors import InvalidRevisionNumber
57
 
 
 
39
from trace import mutter
58
40
 
59
41
def find_touching_revisions(branch, file_id):
60
42
    """Yield a description of revisions which affect the file_id.
101
83
 
102
84
 
103
85
 
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
86
def show_log(branch,
114
 
             lf,
115
87
             specific_fileid=None,
 
88
             show_timezone='original',
116
89
             verbose=False,
 
90
             show_ids=False,
 
91
             to_file=None,
117
92
             direction='reverse',
118
93
             start_revision=None,
119
 
             end_revision=None,
120
 
             search=None):
 
94
             end_revision=None):
121
95
    """Write out human-readable log of commits to this branch.
122
96
 
123
 
    lf
124
 
        LogFormatter object to show the output.
125
 
 
126
97
    specific_fileid
127
98
        If true, list only the commits affecting the specified
128
99
        file, rather than all commits.
129
100
 
 
101
    show_timezone
 
102
        'original' (committer's timezone),
 
103
        'utc' (universal time), or
 
104
        'local' (local user's timezone)
 
105
 
130
106
    verbose
131
107
        If true show added/changed/deleted/renamed files.
132
108
 
 
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
 
133
115
    direction
134
116
        'reverse' (default) is latest to earliest;
135
117
        'forward' is earliest to latest.
140
122
    end_revision
141
123
        If not None, only show revisions <= end_revision
142
124
    """
143
 
    from bzrlib.osutils import format_date
144
 
    from bzrlib.errors import BzrCheckError
145
 
    from bzrlib.textui import show_status
146
 
    
147
 
    from warnings import warn
 
125
    from osutils import format_date
 
126
    from errors import BzrCheckError
 
127
    from textui import show_status
148
128
 
149
 
    if not isinstance(lf, LogFormatter):
150
 
        warn("not a LogFormatter instance: %r" % lf)
151
129
 
152
130
    if specific_fileid:
153
131
        mutter('get log for file_id %r' % specific_fileid)
154
132
 
155
 
    if search is not None:
156
 
        import re
157
 
        searchRE = re.compile(search, re.IGNORECASE)
158
 
    else:
159
 
        searchRE = None
160
 
 
161
 
    which_revs = _enumerate_history(branch)
162
 
    
163
 
    if start_revision is None:
164
 
        start_revision = 1
165
 
    elif start_revision < 1 or start_revision >= len(which_revs):
166
 
        raise InvalidRevisionNumber(start_revision)
167
 
    
168
 
    if end_revision is None:
169
 
        end_revision = len(which_revs)
170
 
    elif end_revision < 1 or end_revision >= len(which_revs):
171
 
        raise InvalidRevisionNumber(end_revision)
172
 
 
173
 
    # list indexes are 0-based; revisions are 1-based
174
 
    cut_revs = which_revs[(start_revision-1):(end_revision)]
175
 
 
176
 
    if direction == 'reverse':
177
 
        cut_revs.reverse()
178
 
    elif direction == 'forward':
179
 
        pass
180
 
    else:
181
 
        raise ValueError('invalid direction %r' % direction)
182
 
 
183
 
    for revno, rev_id in cut_revs:
184
 
        if verbose or specific_fileid:
185
 
            delta = branch.get_revision_delta(revno)
186
 
            
 
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:
187
148
        if specific_fileid:
188
149
            if not delta.touches_file_id(specific_fileid):
189
150
                continue
190
151
 
 
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
        
191
158
        if not verbose:
192
159
            # although we calculated it, throw it away without display
193
160
            delta = None
194
 
 
195
 
        rev = branch.get_revision(rev_id)
196
 
 
197
 
        if searchRE:
198
 
            if not searchRE.search(rev.message):
199
 
                continue
200
 
 
201
 
        lf.show(revno, rev, delta)
 
161
            
 
162
        show_one_log(revno, rev, delta, show_ids, to_file, show_timezone)
202
163
 
203
164
 
204
165
 
205
166
def deltas_for_log_dummy(branch, which_revs):
206
 
    """Return all the revisions without intermediate deltas.
207
 
 
208
 
    Useful for log commands that won't need the delta information.
209
 
    """
210
 
    
211
167
    for revno, revision_id in which_revs:
212
168
        yield revno, branch.get_revision(revision_id), None
213
169
 
214
170
 
215
171
def deltas_for_log_reverse(branch, which_revs):
216
 
    """Compute deltas for display in latest-to-earliest order.
217
 
 
218
 
    branch
219
 
        Branch to traverse
220
 
 
221
 
    which_revs
222
 
        Sequence of (revno, revision_id) for the subset of history to examine
223
 
 
224
 
    returns 
225
 
        Sequence of (revno, rev, delta)
 
172
    """Compute deltas for display in reverse log.
 
173
 
 
174
    Given a sequence of (revno, revision_id) pairs, return
 
175
    (revno, rev, delta).
226
176
 
227
177
    The delta is from the given revision to the next one in the
228
178
    sequence, which makes sense if the log is being displayed from
229
179
    newest to oldest.
230
180
    """
 
181
    from tree import EmptyTree
 
182
    from diff import compare_trees
 
183
    
231
184
    last_revno = last_revision_id = last_tree = None
232
185
    for revno, revision_id in which_revs:
233
186
        this_tree = branch.revision_tree(revision_id)
236
189
        if last_revno:
237
190
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
238
191
 
239
 
        this_tree = EmptyTree(branch.get_root_id())
240
 
 
241
192
        last_revno = revno
242
193
        last_revision = this_revision
243
194
        last_tree = this_tree
244
195
 
245
196
    if last_revno:
246
 
        if last_revno == 1:
247
 
            this_tree = EmptyTree(branch.get_root_id())
248
 
        else:
249
 
            this_revno = last_revno - 1
250
 
            this_revision_id = branch.revision_history()[this_revno]
251
 
            this_tree = branch.revision_tree(this_revision_id)
 
197
        this_tree = EmptyTree()
252
198
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
253
199
 
254
200
 
255
 
def deltas_for_log_forward(branch, which_revs):
256
 
    """Compute deltas for display in forward log.
257
 
 
258
 
    Given a sequence of (revno, revision_id) pairs, return
259
 
    (revno, rev, delta).
260
 
 
261
 
    The delta is from the given revision to the next one in the
262
 
    sequence, which makes sense if the log is being displayed from
263
 
    newest to oldest.
264
 
    """
265
 
    last_revno = last_revision_id = last_tree = None
266
 
    prev_tree = EmptyTree(branch.get_root_id())
267
 
 
 
201
 
 
202
def junk():
 
203
    precursor = None
 
204
    if verbose:
 
205
        from tree import EmptyTree
 
206
        prev_tree = EmptyTree()
268
207
    for revno, revision_id in which_revs:
 
208
        precursor = revision_id
 
209
 
 
210
    if revision_id != rev.revision_id:
 
211
        raise BzrCheckError("retrieved wrong revision: %r"
 
212
                            % (revision_id, rev.revision_id))
 
213
 
 
214
    if verbose:
269
215
        this_tree = branch.revision_tree(revision_id)
270
 
        this_revision = branch.get_revision(revision_id)
271
 
 
272
 
        if not last_revno:
273
 
            if revno == 1:
274
 
                last_tree = EmptyTree(branch.get_root_id())
275
 
            else:
276
 
                last_revno = revno - 1
277
 
                last_revision_id = branch.revision_history()[last_revno]
278
 
                last_tree = branch.revision_tree(last_revision_id)
279
 
 
280
 
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
281
 
 
282
 
        last_revno = revno
283
 
        last_revision = this_revision
284
 
        last_tree = this_tree
285
 
 
286
 
 
287
 
class LogFormatter(object):
288
 
    """Abstract class to display log messages."""
289
 
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
290
 
        self.to_file = to_file
291
 
        self.show_ids = show_ids
292
 
        self.show_timezone = show_timezone
293
 
 
294
 
 
295
 
    def show(self, revno, rev, delta):
296
 
        raise NotImplementedError('not implemented in abstract base')
297
 
        
298
 
 
299
 
 
300
 
 
301
 
 
302
 
 
303
 
class LongLogFormatter(LogFormatter):
304
 
    def show(self, revno, rev, delta):
305
 
        from osutils import format_date
306
 
 
307
 
        to_file = self.to_file
308
 
 
309
 
        print >>to_file,  '-' * 60
310
 
        print >>to_file,  'revno:', revno
311
 
        if self.show_ids:
312
 
            print >>to_file,  'revision-id:', rev.revision_id
313
 
        print >>to_file,  'committer:', rev.committer
314
 
 
315
 
        date_str = format_date(rev.timestamp,
316
 
                               rev.timezone or 0,
317
 
                               self.show_timezone)
318
 
        print >>to_file,  'timestamp: %s' % date_str
319
 
 
320
 
        print >>to_file,  'message:'
321
 
        if not rev.message:
322
 
            print >>to_file,  '  (no message)'
323
 
        else:
324
 
            for l in rev.message.split('\n'):
325
 
                print >>to_file,  '  ' + l
326
 
 
327
 
        if delta != None:
328
 
            delta.show(to_file, self.show_ids)
329
 
 
330
 
 
331
 
 
332
 
class ShortLogFormatter(LogFormatter):
333
 
    def show(self, revno, rev, delta):
334
 
        from bzrlib.osutils import format_date
335
 
 
336
 
        to_file = self.to_file
337
 
 
338
 
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
339
 
                format_date(rev.timestamp, rev.timezone or 0,
340
 
                            self.show_timezone))
341
 
        if self.show_ids:
342
 
            print >>to_file,  '      revision-id:', rev.revision_id
343
 
        if not rev.message:
344
 
            print >>to_file,  '      (no message)'
345
 
        else:
346
 
            for l in rev.message.split('\n'):
347
 
                print >>to_file,  '      ' + l
348
 
 
349
 
        # TODO: Why not show the modified files in a shorter form as
350
 
        # well? rewrap them single lines of appropriate length
351
 
        if delta != None:
352
 
            delta.show(to_file, self.show_ids)
353
 
        print
354
 
 
355
 
 
356
 
 
357
 
FORMATTERS = {'long': LongLogFormatter,
358
 
              'short': ShortLogFormatter,
359
 
              }
360
 
 
361
 
 
362
 
def log_formatter(name, *args, **kwargs):
363
 
    from bzrlib.errors import BzrCommandError
 
216
        delta = compare_trees(prev_tree, this_tree, want_unchanged=False)
 
217
        prev_tree = this_tree
 
218
    else:
 
219
        delta = None    
 
220
 
 
221
 
 
222
 
 
223
def show_one_log(revno, rev, delta, show_ids, to_file, show_timezone):
 
224
    from osutils import format_date
364
225
    
365
 
    try:
366
 
        return FORMATTERS[name](*args, **kwargs)
367
 
    except IndexError:
368
 
        raise BzrCommandError("unknown log formatter: %r" % name)
369
 
 
370
 
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
371
 
    # deprecated; for compatability
372
 
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
373
 
    lf.show(revno, rev, delta)
 
226
    print >>to_file,  '-' * 60
 
227
    print >>to_file,  'revno:', revno
 
228
    if show_ids:
 
229
        print >>to_file,  'revision-id:', rev.revision_id
 
230
    print >>to_file,  'committer:', rev.committer
 
231
    print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
 
232
                                         show_timezone))
 
233
 
 
234
    print >>to_file,  'message:'
 
235
    if not rev.message:
 
236
        print >>to_file,  '  (no message)'
 
237
    else:
 
238
        for l in rev.message.split('\n'):
 
239
            print >>to_file,  '  ' + l
 
240
 
 
241
    if delta != None:
 
242
        delta.show(to_file, show_ids)