~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: aaron.bentley at utoronto
  • Date: 2005-09-05 01:31:37 UTC
  • mto: (1185.3.4)
  • mto: This revision was merged to the branch mainline in revision 1178.
  • Revision ID: aaron.bentley@utoronto.ca-20050905013137-c8b598b5a90a52a9
Fixed the revno bug in log

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