← 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-07-11 06:41:00 UTC
  • mfrom: (unknown (missing))
  • Revision ID: mbp@sourcefrog.net-20050711064100-c2eb947e0212f487
- patch from john to search for matching commits

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
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
 
# TODO: option to show delta summaries for merged-in revisions
53
 
 
54
 
from itertools import izip
55
 
import re
56
 
 
57
 
from bzrlib.delta import compare_trees
58
 
import bzrlib.errors as errors
59
 
from bzrlib.trace import mutter
60
 
from bzrlib.tree import EmptyTree
61
 
from bzrlib.tsort import merge_sort
62
 
 
 
38
 
 
39
from trace import mutter
63
40
 
64
41
def find_touching_revisions(branch, file_id):
65
42
    """Yield a description of revisions which affect the file_id.
76
53
    last_path = None
77
54
    revno = 1
78
55
    for revision_id in branch.revision_history():
79
 
        this_inv = branch.repository.get_revision_inventory(revision_id)
 
56
        this_inv = branch.get_revision_inventory(revision_id)
80
57
        if file_id in this_inv:
81
58
            this_ie = this_inv[file_id]
82
59
            this_path = this_inv.id2path(file_id)
106
83
 
107
84
 
108
85
 
109
 
def _enumerate_history(branch):
110
 
    rh = []
111
 
    revno = 1
112
 
    for rev_id in branch.revision_history():
113
 
        rh.append((revno, rev_id))
114
 
        revno += 1
115
 
    return rh
116
 
 
117
 
 
118
 
def _get_revision_delta(branch, revno):
119
 
    """Return the delta for a mainline revision.
120
 
    
121
 
    This is used to show summaries in verbose logs, and also for finding 
122
 
    revisions which touch a given file."""
123
 
    # XXX: What are we supposed to do when showing a summary for something 
124
 
    # other than a mainline revision.  The delta to it's first parent, or
125
 
    # (more useful) the delta to a nominated other revision.
126
 
    return branch.get_revision_delta(revno)
127
 
 
128
 
 
129
86
def show_log(branch,
130
87
             lf,
131
88
             specific_fileid=None,
156
113
    end_revision
157
114
        If not None, only show revisions <= end_revision
158
115
    """
159
 
    branch.lock_read()
160
 
    try:
161
 
        _show_log(branch, lf, specific_fileid, verbose, direction,
162
 
                  start_revision, end_revision, search)
163
 
    finally:
164
 
        branch.unlock()
165
 
    
166
 
def _show_log(branch,
167
 
             lf,
168
 
             specific_fileid=None,
169
 
             verbose=False,
170
 
             direction='reverse',
171
 
             start_revision=None,
172
 
             end_revision=None,
173
 
             search=None):
174
 
    """Worker function for show_log - see show_log."""
175
116
    from bzrlib.osutils import format_date
176
117
    from bzrlib.errors import BzrCheckError
177
118
    from bzrlib.textui import show_status
182
123
        warn("not a LogFormatter instance: %r" % lf)
183
124
 
184
125
    if specific_fileid:
185
 
        mutter('get log for file_id %r', specific_fileid)
 
126
        mutter('get log for file_id %r' % specific_fileid)
186
127
 
187
128
    if search is not None:
188
129
        import re
190
131
    else:
191
132
        searchRE = None
192
133
 
193
 
    which_revs = _enumerate_history(branch)
194
 
    
195
 
    if start_revision is None:
196
 
        start_revision = 1
197
 
    else:
198
 
        branch.check_real_revno(start_revision)
199
 
    
200
 
    if end_revision is None:
201
 
        end_revision = len(which_revs)
202
 
    else:
203
 
        branch.check_real_revno(end_revision)
204
 
 
205
 
    # list indexes are 0-based; revisions are 1-based
206
 
    cut_revs = which_revs[(start_revision-1):(end_revision)]
207
 
    if not cut_revs:
208
 
        return
209
 
    # override the mainline to look like the revision history.
210
 
    mainline_revs = [revision_id for index, revision_id in cut_revs]
211
 
    if cut_revs[0][0] == 1:
212
 
        mainline_revs.insert(0, None)
213
 
    else:
214
 
        mainline_revs.insert(0, which_revs[start_revision-2][1])
215
 
 
216
 
    merge_sorted_revisions = merge_sort(
217
 
        branch.repository.get_revision_graph(mainline_revs[-1]),
218
 
        mainline_revs[-1],
219
 
        mainline_revs)
220
 
 
221
 
    if direction == 'reverse':
222
 
        cut_revs.reverse()
223
 
    elif direction == 'forward':
224
 
        # forward means oldest first.
225
 
        merge_sorted_revisions.reverse()
226
 
    else:
227
 
        raise ValueError('invalid direction %r' % direction)
228
 
 
229
 
    revision_history = branch.revision_history()
230
 
 
231
 
    # convert the revision history to a dictionary:
232
 
    rev_nos = {}
233
 
    for index, rev_id in cut_revs:
234
 
        rev_nos[rev_id] = index
235
 
 
236
 
    def iter_revisions():
237
 
        revision_ids = [r for s, r, m, e in merge_sorted_revisions]
238
 
        num = 9
239
 
        while revision_ids:
240
 
            revisions = branch.repository.get_revisions(revision_ids[:num])
241
 
            for revision in revisions:
242
 
                yield revision
243
 
            revision_ids  = revision_ids[num:]
244
 
            num = int(num * 1.5)
245
 
            
246
 
        revisions = branch.repository.get_revisions()
247
 
        for revision in revisions:
248
 
            yield revision
249
 
    # now we just print all the revisions
250
 
    for ((sequence, rev_id, merge_depth, end_of_merge), rev) in \
251
 
        izip(merge_sorted_revisions, iter_revisions()):
252
 
 
253
 
        if searchRE:
254
 
            if not searchRE.search(rev.message):
 
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:
 
148
        if specific_fileid:
 
149
            if not delta.touches_file_id(specific_fileid):
255
150
                continue
256
151
 
257
 
        if merge_depth == 0:
258
 
            # a mainline revision.
259
 
            if verbose or specific_fileid:
260
 
                delta = _get_revision_delta(branch, rev_nos[rev_id])
261
 
                
262
 
            if specific_fileid:
263
 
                if not delta.touches_file_id(specific_fileid):
264
 
                    continue
 
152
        if not verbose:
 
153
            # although we calculated it, throw it away without display
 
154
            delta = None
 
155
 
 
156
        if searchRE is None or searchRE.search(rev.message):
 
157
            lf.show(revno, rev, delta)
 
158
 
 
159
 
 
160
 
 
161
def deltas_for_log_dummy(branch, which_revs):
 
162
    for revno, revision_id in which_revs:
 
163
        yield revno, branch.get_revision(revision_id), None
 
164
 
 
165
 
 
166
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).
 
171
 
 
172
    The delta is from the given revision to the next one in the
 
173
    sequence, which makes sense if the log is being displayed from
 
174
    newest to oldest.
 
175
    """
 
176
    from tree import EmptyTree
 
177
    from diff import compare_trees
265
178
    
266
 
            if not verbose:
267
 
                # although we calculated it, throw it away without display
268
 
                delta = None
269
 
 
270
 
            lf.show(rev_nos[rev_id], rev, delta)
271
 
        elif hasattr(lf, 'show_merge'):
272
 
            lf.show_merge(rev, merge_depth)
 
179
    last_revno = last_revision_id = last_tree = None
 
180
    for revno, revision_id in which_revs:
 
181
        this_tree = branch.revision_tree(revision_id)
 
182
        this_revision = branch.get_revision(revision_id)
 
183
        
 
184
        if last_revno:
 
185
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
186
 
 
187
        last_revno = revno
 
188
        last_revision = this_revision
 
189
        last_tree = this_tree
 
190
 
 
191
    if last_revno:
 
192
        if last_revno == 1:
 
193
            this_tree = EmptyTree()
 
194
        else:
 
195
            this_revno = last_revno - 1
 
196
            this_revision_id = branch.revision_history()[this_revno]
 
197
            this_tree = branch.revision_tree(this_revision_id)
 
198
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
199
 
 
200
 
 
201
def deltas_for_log_forward(branch, which_revs):
 
202
    """Compute deltas for display in forward log.
 
203
 
 
204
    Given a sequence of (revno, revision_id) pairs, return
 
205
    (revno, rev, delta).
 
206
 
 
207
    The delta is from the given revision to the next one in the
 
208
    sequence, which makes sense if the log is being displayed from
 
209
    newest to oldest.
 
210
    """
 
211
    from tree import EmptyTree
 
212
    from diff import compare_trees
 
213
 
 
214
    last_revno = last_revision_id = last_tree = None
 
215
    for revno, revision_id in which_revs:
 
216
        this_tree = branch.revision_tree(revision_id)
 
217
        this_revision = branch.get_revision(revision_id)
 
218
 
 
219
        if not last_revno:
 
220
            if revno == 1:
 
221
                last_tree = EmptyTree()
 
222
            else:
 
223
                last_revno = revno - 1
 
224
                last_revision_id = branch.revision_history()[last_revno]
 
225
                last_tree = branch.revision_tree(last_revision_id)
 
226
 
 
227
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
228
 
 
229
        last_revno = revno
 
230
        last_revision = this_revision
 
231
        last_tree = this_tree
273
232
 
274
233
 
275
234
class LogFormatter(object):
276
235
    """Abstract class to display log messages."""
277
 
 
278
 
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
236
    def __init__(self, to_file, show_ids=False, show_timezone=False):
279
237
        self.to_file = to_file
280
238
        self.show_ids = show_ids
281
239
        self.show_timezone = show_timezone
282
 
 
283
 
    def show(self, revno, rev, delta):
284
 
        raise NotImplementedError('not implemented in abstract base')
285
 
 
286
 
    def short_committer(self, rev):
287
 
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
288
 
    
289
 
    
 
240
        
 
241
 
 
242
 
 
243
 
 
244
 
 
245
 
290
246
class LongLogFormatter(LogFormatter):
291
247
    def show(self, revno, rev, delta):
292
 
        return self._show_helper(revno=revno, rev=rev, delta=delta)
293
 
 
294
 
    def show_merge(self, rev, merge_depth):
295
 
        return self._show_helper(rev=rev, indent='    '*merge_depth, merged=True, delta=None)
296
 
 
297
 
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
298
 
        """Show a revision, either merged or not."""
299
 
        from bzrlib.osutils import format_date
 
248
        from osutils import format_date
 
249
 
300
250
        to_file = self.to_file
301
 
        print >>to_file,  indent+'-' * 60
302
 
        if revno is not None:
303
 
            print >>to_file,  'revno:', revno
304
 
        if merged:
305
 
            print >>to_file,  indent+'merged:', rev.revision_id
306
 
        elif self.show_ids:
307
 
            print >>to_file,  indent+'revision-id:', rev.revision_id
 
251
 
 
252
        print >>to_file,  '-' * 60
 
253
        print >>to_file,  'revno:', revno
308
254
        if self.show_ids:
309
 
            for parent_id in rev.parent_ids:
310
 
                print >>to_file, indent+'parent:', parent_id
311
 
        print >>to_file,  indent+'committer:', rev.committer
312
 
        try:
313
 
            print >>to_file, indent+'branch nick: %s' % \
314
 
                rev.properties['branch-nick']
315
 
        except KeyError:
316
 
            pass
317
 
        date_str = format_date(rev.timestamp,
318
 
                               rev.timezone or 0,
319
 
                               self.show_timezone)
320
 
        print >>to_file,  indent+'timestamp: %s' % date_str
 
255
            print >>to_file,  'revision-id:', rev.revision_id
 
256
        print >>to_file,  'committer:', rev.committer
 
257
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
 
258
                                             self.show_timezone))
321
259
 
322
 
        print >>to_file,  indent+'message:'
 
260
        print >>to_file,  'message:'
323
261
        if not rev.message:
324
 
            print >>to_file,  indent+'  (no message)'
 
262
            print >>to_file,  '  (no message)'
325
263
        else:
326
 
            message = rev.message.rstrip('\r\n')
327
 
            for l in message.split('\n'):
328
 
                print >>to_file,  indent+'  ' + l
 
264
            for l in rev.message.split('\n'):
 
265
                print >>to_file,  '  ' + l
 
266
 
329
267
        if delta != None:
330
268
            delta.show(to_file, self.show_ids)
331
269
 
332
270
 
 
271
 
333
272
class ShortLogFormatter(LogFormatter):
334
273
    def show(self, revno, rev, delta):
335
274
        from bzrlib.osutils import format_date
336
275
 
337
276
        to_file = self.to_file
338
 
        date_str = format_date(rev.timestamp, rev.timezone or 0,
339
 
                            self.show_timezone)
340
 
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
 
277
 
 
278
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
341
279
                format_date(rev.timestamp, rev.timezone or 0,
342
 
                            self.show_timezone, date_fmt="%Y-%m-%d",
343
 
                           show_offset=False))
 
280
                            self.show_timezone))
344
281
        if self.show_ids:
345
282
            print >>to_file,  '      revision-id:', rev.revision_id
346
283
        if not rev.message:
347
284
            print >>to_file,  '      (no message)'
348
285
        else:
349
 
            message = rev.message.rstrip('\r\n')
350
 
            for l in message.split('\n'):
 
286
            for l in rev.message.split('\n'):
351
287
                print >>to_file,  '      ' + l
352
288
 
353
 
        # TODO: Why not show the modified files in a shorter form as
354
 
        # well? rewrap them single lines of appropriate length
355
289
        if delta != None:
356
290
            delta.show(to_file, self.show_ids)
357
 
        print >>to_file, ''
358
 
 
359
 
 
360
 
class LineLogFormatter(LogFormatter):
361
 
    def truncate(self, str, max_len):
362
 
        if len(str) <= max_len:
363
 
            return str
364
 
        return str[:max_len-3]+'...'
365
 
 
366
 
    def date_string(self, rev):
367
 
        from bzrlib.osutils import format_date
368
 
        return format_date(rev.timestamp, rev.timezone or 0, 
369
 
                           self.show_timezone, date_fmt="%Y-%m-%d",
370
 
                           show_offset=False)
371
 
 
372
 
    def message(self, rev):
373
 
        if not rev.message:
374
 
            return '(no message)'
375
 
        else:
376
 
            return rev.message
377
 
 
378
 
    def show(self, revno, rev, delta):
379
 
        from bzrlib.osutils import terminal_width
380
 
        print >> self.to_file, self.log_string(revno, rev, terminal_width()-1)
381
 
 
382
 
    def log_string(self, revno, rev, max_chars):
383
 
        """Format log info into one string. Truncate tail of string
384
 
        :param  revno:      revision number (int) or None.
385
 
                            Revision numbers counts from 1.
386
 
        :param  rev:        revision info object
387
 
        :param  max_chars:  maximum length of resulting string
388
 
        :return:            formatted truncated string
389
 
        """
390
 
        out = []
391
 
        if revno:
392
 
            # show revno only when is not None
393
 
            out.append("%d:" % revno)
394
 
        out.append(self.truncate(self.short_committer(rev), 20))
395
 
        out.append(self.date_string(rev))
396
 
        out.append(rev.get_summary())
397
 
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
398
 
 
399
 
 
400
 
def line_log(rev, max_chars):
401
 
    lf = LineLogFormatter(None)
402
 
    return lf.log_string(None, rev, max_chars)
403
 
 
404
 
FORMATTERS = {
405
 
              'long': LongLogFormatter,
 
291
        print
 
292
 
 
293
 
 
294
 
 
295
FORMATTERS = {'long': LongLogFormatter,
406
296
              'short': ShortLogFormatter,
407
 
              'line': LineLogFormatter,
408
297
              }
409
298
 
410
 
def register_formatter(name, formatter):
411
 
    FORMATTERS[name] = formatter
412
299
 
413
300
def log_formatter(name, *args, **kwargs):
414
 
    """Construct a formatter from arguments.
415
 
 
416
 
    name -- Name of the formatter to construct; currently 'long', 'short' and
417
 
        'line' are supported.
418
 
    """
419
301
    from bzrlib.errors import BzrCommandError
 
302
    
420
303
    try:
421
304
        return FORMATTERS[name](*args, **kwargs)
422
 
    except KeyError:
 
305
    except IndexError:
423
306
        raise BzrCommandError("unknown log formatter: %r" % name)
424
 
 
425
 
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
426
 
    # deprecated; for compatibility
427
 
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
428
 
    lf.show(revno, rev, delta)
429
 
 
430
 
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
431
 
    """Show the change in revision history comparing the old revision history to the new one.
432
 
 
433
 
    :param branch: The branch where the revisions exist
434
 
    :param old_rh: The old revision history
435
 
    :param new_rh: The new revision history
436
 
    :param to_file: A file to write the results to. If None, stdout will be used
437
 
    """
438
 
    if to_file is None:
439
 
        import sys
440
 
        import codecs
441
 
        import bzrlib
442
 
        to_file = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
443
 
    lf = log_formatter(log_format,
444
 
                       show_ids=False,
445
 
                       to_file=to_file,
446
 
                       show_timezone='original')
447
 
 
448
 
    # This is the first index which is different between
449
 
    # old and new
450
 
    base_idx = None
451
 
    for i in xrange(max(len(new_rh),
452
 
                        len(old_rh))):
453
 
        if (len(new_rh) <= i
454
 
            or len(old_rh) <= i
455
 
            or new_rh[i] != old_rh[i]):
456
 
            base_idx = i
457
 
            break
458
 
 
459
 
    if base_idx is None:
460
 
        to_file.write('Nothing seems to have changed\n')
461
 
        return
462
 
    ## TODO: It might be nice to do something like show_log
463
 
    ##       and show the merged entries. But since this is the
464
 
    ##       removed revisions, it shouldn't be as important
465
 
    if base_idx < len(old_rh):
466
 
        to_file.write('*'*60)
467
 
        to_file.write('\nRemoved Revisions:\n')
468
 
        for i in range(base_idx, len(old_rh)):
469
 
            rev = branch.repository.get_revision(old_rh[i])
470
 
            lf.show(i+1, rev, None)
471
 
        to_file.write('*'*60)
472
 
        to_file.write('\n\n')
473
 
    if base_idx < len(new_rh):
474
 
        to_file.write('Added Revisions:\n')
475
 
        show_log(branch,
476
 
                 lf,
477
 
                 None,
478
 
                 verbose=True,
479
 
                 direction='forward',
480
 
                 start_revision=base_idx+1,
481
 
                 end_revision=len(new_rh),
482
 
                 search=None)
483