~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Robert Collins
  • Date: 2005-10-16 23:53:02 UTC
  • mto: This revision was merged to the branch mainline in revision 1459.
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051016235302-818de607403e1c6e
test that the presence of a signature does not make a missing base file magically appear present

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
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
 
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
 
 
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
 
86
124
def show_log(branch,
87
125
             lf,
88
126
             specific_fileid=None,
113
151
    end_revision
114
152
        If not None, only show revisions <= end_revision
115
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."""
116
170
    from bzrlib.osutils import format_date
117
171
    from bzrlib.errors import BzrCheckError
118
172
    from bzrlib.textui import show_status
131
185
    else:
132
186
        searchRE = None
133
187
 
134
 
    which_revs = branch.enum_history(direction)
135
 
    which_revs = [x for x in which_revs if (
136
 
            (start_revision is None or x[0] >= start_revision)
137
 
            and (end_revision is None or x[0] <= end_revision))]
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
 
        with_deltas = deltas_for_log_forward(branch, which_revs)
146
 
 
147
 
    for revno, rev, delta in with_deltas:
 
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
            
148
215
        if specific_fileid:
149
216
            if not delta.touches_file_id(specific_fileid):
150
217
                continue
153
220
            # although we calculated it, throw it away without display
154
221
            delta = None
155
222
 
156
 
        if searchRE is None or searchRE.search(rev.message):
157
 
            lf.show(revno, rev, delta)
158
 
 
 
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)
159
248
 
160
249
 
161
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
    
162
256
    for revno, revision_id in which_revs:
163
257
        yield revno, branch.get_revision(revision_id), None
164
258
 
165
259
 
166
260
def deltas_for_log_reverse(branch, which_revs):
167
 
    """Compute deltas for display in reverse log.
168
 
 
169
 
    Given a sequence of (revno, revision_id) pairs, return
170
 
    (revno, rev, delta).
 
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)
171
271
 
172
272
    The delta is from the given revision to the next one in the
173
273
    sequence, which makes sense if the log is being displayed from
174
274
    newest to oldest.
175
275
    """
176
 
    from tree import EmptyTree
177
 
    from diff import compare_trees
178
 
    
179
276
    last_revno = last_revision_id = last_tree = None
180
277
    for revno, revision_id in which_revs:
181
278
        this_tree = branch.revision_tree(revision_id)
210
307
    sequence, which makes sense if the log is being displayed from
211
308
    newest to oldest.
212
309
    """
213
 
    from tree import EmptyTree
214
 
    from diff import compare_trees
215
 
 
216
310
    last_revno = last_revision_id = last_tree = None
217
311
    prev_tree = EmptyTree(branch.get_root_id())
218
312
 
237
331
 
238
332
class LogFormatter(object):
239
333
    """Abstract class to display log messages."""
240
 
    def __init__(self, to_file, show_ids=False, show_timezone=False):
 
334
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
241
335
        self.to_file = to_file
242
336
        self.show_ids = show_ids
243
337
        self.show_timezone = show_timezone
244
 
        
245
 
 
246
 
 
247
 
 
248
 
 
249
 
 
 
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
    
250
347
class LongLogFormatter(LogFormatter):
251
348
    def show(self, revno, rev, delta):
252
349
        from osutils import format_date
257
354
        print >>to_file,  'revno:', revno
258
355
        if self.show_ids:
259
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
            
260
361
        print >>to_file,  'committer:', rev.committer
261
 
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
262
 
                                             self.show_timezone))
 
362
 
 
363
        date_str = format_date(rev.timestamp,
 
364
                               rev.timezone or 0,
 
365
                               self.show_timezone)
 
366
        print >>to_file,  'timestamp: %s' % date_str
263
367
 
264
368
        print >>to_file,  'message:'
265
369
        if not rev.message:
271
375
        if delta != None:
272
376
            delta.show(to_file, self.show_ids)
273
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
274
404
 
275
405
 
276
406
class ShortLogFormatter(LogFormatter):
290
420
            for l in rev.message.split('\n'):
291
421
                print >>to_file,  '      ' + l
292
422
 
 
423
        # TODO: Why not show the modified files in a shorter form as
 
424
        # well? rewrap them single lines of appropriate length
293
425
        if delta != None:
294
426
            delta.show(to_file, self.show_ids)
295
427
        print
302
434
 
303
435
 
304
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
    """
305
442
    from bzrlib.errors import BzrCommandError
306
 
    
307
443
    try:
308
444
        return FORMATTERS[name](*args, **kwargs)
309
445
    except IndexError:
310
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)