← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Jelmer Vernooij
  • Date: 2006-06-21 13:54:14 UTC
  • mto: (1558.14.8 Aaron's integration)
  • mto: This revision was merged to the branch mainline in revision 1803.
  • Revision ID: jelmer@samba.org-20060621135414-11a3a70e53adbb99
Install benchmarks.

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
 
* 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
 
 
39
 
from trace import mutter
 
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
 
40
63
 
41
64
def find_touching_revisions(branch, file_id):
42
65
    """Yield a description of revisions which affect the file_id.
53
76
    last_path = None
54
77
    revno = 1
55
78
    for revision_id in branch.revision_history():
56
 
        this_inv = branch.get_revision_inventory(revision_id)
 
79
        this_inv = branch.repository.get_revision_inventory(revision_id)
57
80
        if file_id in this_inv:
58
81
            this_ie = this_inv[file_id]
59
82
            this_path = this_inv.id2path(file_id)
83
106
 
84
107
 
85
108
 
 
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
 
86
129
def show_log(branch,
 
130
             lf,
87
131
             specific_fileid=None,
88
 
             show_timezone='original',
89
132
             verbose=False,
90
 
             show_ids=False,
91
 
             to_file=None,
92
133
             direction='reverse',
93
134
             start_revision=None,
94
 
             end_revision=None):
 
135
             end_revision=None,
 
136
             search=None):
95
137
    """Write out human-readable log of commits to this branch.
96
138
 
 
139
    lf
 
140
        LogFormatter object to show the output.
 
141
 
97
142
    specific_fileid
98
143
        If true, list only the commits affecting the specified
99
144
        file, rather than all commits.
100
145
 
101
 
    show_timezone
102
 
        'original' (committer's timezone),
103
 
        'utc' (universal time), or
104
 
        'local' (local user's timezone)
105
 
 
106
146
    verbose
107
147
        If true show added/changed/deleted/renamed files.
108
148
 
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
149
    direction
116
150
        'reverse' (default) is latest to earliest;
117
151
        'forward' is earliest to latest.
122
156
    end_revision
123
157
        If not None, only show revisions <= end_revision
124
158
    """
125
 
    from osutils import format_date
126
 
    from errors import BzrCheckError
127
 
    from textui import show_status
 
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
    from bzrlib.osutils import format_date
 
176
    from bzrlib.errors import BzrCheckError
 
177
    from bzrlib.textui import show_status
 
178
    
 
179
    from warnings import warn
128
180
 
 
181
    if not isinstance(lf, LogFormatter):
 
182
        warn("not a LogFormatter instance: %r" % lf)
129
183
 
130
184
    if specific_fileid:
131
 
        mutter('get log for file_id %r' % specific_fileid)
132
 
 
133
 
    if to_file == None:
 
185
        mutter('get log for file_id %r', specific_fileid)
 
186
 
 
187
    if search is not None:
 
188
        import re
 
189
        searchRE = re.compile(search, re.IGNORECASE)
 
190
    else:
 
191
        searchRE = None
 
192
 
 
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):
 
255
                continue
 
256
 
 
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
 
265
    
 
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)
 
273
 
 
274
 
 
275
class LogFormatter(object):
 
276
    """Abstract class to display log messages."""
 
277
 
 
278
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
279
        self.to_file = to_file
 
280
        self.show_ids = show_ids
 
281
        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
    
 
290
class LongLogFormatter(LogFormatter):
 
291
    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
 
300
        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
 
308
        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
 
321
 
 
322
        print >>to_file,  indent+'message:'
 
323
        if not rev.message:
 
324
            print >>to_file,  indent+'  (no message)'
 
325
        else:
 
326
            message = rev.message.rstrip('\r\n')
 
327
            for l in message.split('\n'):
 
328
                print >>to_file,  indent+'  ' + l
 
329
        if delta != None:
 
330
            delta.show(to_file, self.show_ids)
 
331
 
 
332
 
 
333
class ShortLogFormatter(LogFormatter):
 
334
    def show(self, revno, rev, delta):
 
335
        from bzrlib.osutils import format_date
 
336
 
 
337
        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),
 
341
                format_date(rev.timestamp, rev.timezone or 0,
 
342
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
343
                           show_offset=False))
 
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
            message = rev.message.rstrip('\r\n')
 
350
            for l in message.split('\n'):
 
351
                print >>to_file,  '      ' + l
 
352
 
 
353
        # TODO: Why not show the modified files in a shorter form as
 
354
        # well? rewrap them single lines of appropriate length
 
355
        if delta != None:
 
356
            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,
 
406
              'short': ShortLogFormatter,
 
407
              'line': LineLogFormatter,
 
408
              }
 
409
 
 
410
def register_formatter(name, formatter):
 
411
    FORMATTERS[name] = formatter
 
412
 
 
413
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
    from bzrlib.errors import BzrCommandError
 
420
    try:
 
421
        return FORMATTERS[name](*args, **kwargs)
 
422
    except KeyError:
 
423
        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:
134
439
        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:
148
 
        if specific_fileid:
149
 
            if not delta.touches_file_id(specific_fileid):
150
 
                continue
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
 
        
158
 
        if not verbose:
159
 
            # although we calculated it, throw it away without display
160
 
            delta = None
161
 
            
162
 
        show_one_log(revno, rev, delta, show_ids, to_file, show_timezone)
163
 
 
164
 
 
165
 
 
166
 
def deltas_for_log_dummy(branch, which_revs):
167
 
    for revno, revision_id in which_revs:
168
 
        yield revno, branch.get_revision(revision_id), None
169
 
 
170
 
 
171
 
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).
176
 
 
177
 
    The delta is from the given revision to the next one in the
178
 
    sequence, which makes sense if the log is being displayed from
179
 
    newest to oldest.
180
 
    """
181
 
    from tree import EmptyTree
182
 
    from diff import compare_trees
183
 
    
184
 
    last_revno = last_revision_id = last_tree = None
185
 
    for revno, revision_id in which_revs:
186
 
        this_tree = branch.revision_tree(revision_id)
187
 
        this_revision = branch.get_revision(revision_id)
188
 
        
189
 
        if last_revno:
190
 
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
191
 
 
192
 
        last_revno = revno
193
 
        last_revision = this_revision
194
 
        last_tree = this_tree
195
 
 
196
 
    if last_revno:
197
 
        this_tree = EmptyTree()
198
 
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
199
 
 
200
 
 
201
 
 
202
 
def junk():
203
 
    precursor = None
204
 
    if verbose:
205
 
        from tree import EmptyTree
206
 
        prev_tree = EmptyTree()
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:
215
 
        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
225
 
    
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)
 
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