~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-08-25 02:30:04 UTC
  • mto: (1092.1.41) (1185.3.4)
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: aaron.bentley@utoronto.ca-20050825023004-581548615ae1066d
Made revert clear pending-merges

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
from bzrlib.errors import InvalidRevisionNumber
 
57
 
40
58
 
41
59
def find_touching_revisions(branch, file_id):
42
60
    """Yield a description of revisions which affect the file_id.
83
101
 
84
102
 
85
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
 
86
113
def show_log(branch,
 
114
             lf,
87
115
             specific_fileid=None,
88
 
             show_timezone='original',
89
116
             verbose=False,
90
 
             show_ids=False,
91
 
             to_file=None,
92
117
             direction='reverse',
93
118
             start_revision=None,
94
 
             end_revision=None):
 
119
             end_revision=None,
 
120
             search=None):
95
121
    """Write out human-readable log of commits to this branch.
96
122
 
 
123
    lf
 
124
        LogFormatter object to show the output.
 
125
 
97
126
    specific_fileid
98
127
        If true, list only the commits affecting the specified
99
128
        file, rather than all commits.
100
129
 
101
 
    show_timezone
102
 
        'original' (committer's timezone),
103
 
        'utc' (universal time), or
104
 
        'local' (local user's timezone)
105
 
 
106
130
    verbose
107
131
        If true show added/changed/deleted/renamed files.
108
132
 
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
 
 
115
133
    direction
116
134
        'reverse' (default) is latest to earliest;
117
135
        'forward' is earliest to latest.
122
140
    end_revision
123
141
        If not None, only show revisions <= end_revision
124
142
    """
125
 
    from osutils import format_date
126
 
    from errors import BzrCheckError
127
 
    from textui import show_status
 
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
128
148
 
 
149
    if not isinstance(lf, LogFormatter):
 
150
        warn("not a LogFormatter instance: %r" % lf)
129
151
 
130
152
    if specific_fileid:
131
153
        mutter('get log for file_id %r' % specific_fileid)
132
154
 
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:
 
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
            
148
187
        if specific_fileid:
149
188
            if not delta.touches_file_id(specific_fileid):
150
189
                continue
151
190
 
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
 
        
158
191
        if not verbose:
159
192
            # although we calculated it, throw it away without display
160
193
            delta = None
161
 
            
162
 
        show_one_log(revno, rev, delta, show_ids, to_file, show_timezone)
 
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)
163
202
 
164
203
 
165
204
 
166
205
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
    
167
211
    for revno, revision_id in which_revs:
168
212
        yield revno, branch.get_revision(revision_id), None
169
213
 
170
214
 
171
215
def deltas_for_log_reverse(branch, which_revs):
172
 
    """Compute deltas for display in reverse log.
173
 
 
174
 
    Given a sequence of (revno, revision_id) pairs, return
175
 
    (revno, rev, delta).
 
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)
176
226
 
177
227
    The delta is from the given revision to the next one in the
178
228
    sequence, which makes sense if the log is being displayed from
179
229
    newest to oldest.
180
230
    """
181
 
    from tree import EmptyTree
182
 
    from diff import compare_trees
183
 
    
184
231
    last_revno = last_revision_id = last_tree = None
185
232
    for revno, revision_id in which_revs:
186
233
        this_tree = branch.revision_tree(revision_id)
189
236
        if last_revno:
190
237
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
191
238
 
 
239
        this_tree = EmptyTree(branch.get_root_id())
 
240
 
192
241
        last_revno = revno
193
242
        last_revision = this_revision
194
243
        last_tree = this_tree
195
244
 
196
245
    if last_revno:
197
 
        this_tree = EmptyTree()
 
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)
198
252
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
199
253
 
200
254
 
201
 
 
202
 
def junk():
203
 
    precursor = None
204
 
    if verbose:
205
 
        from tree import EmptyTree
206
 
        prev_tree = EmptyTree()
 
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
 
207
268
    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:
215
269
        this_tree = branch.revision_tree(revision_id)
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
 
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
225
364
    
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)
 
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)