~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Robert Collins
  • Date: 2006-05-24 08:14:45 UTC
  • mfrom: (1725.1.1 benchmark)
  • mto: (1725.2.6 commit)
  • mto: This revision was merged to the branch mainline in revision 1729.
  • Revision ID: robertc@robertcollins.net-20060524081445-c046b4406ffc8dfa
(rbc)Merge in benchmark --lsprof-timed lsprofiling feature. (Robert Collins, Martin Pool).

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
 
 
19
"""Code to show logs of changes.
 
20
 
 
21
Various flavors of log can be produced:
 
22
 
 
23
* for one file, or the whole tree, and (not done yet) for
 
24
  files in a given directory
 
25
 
 
26
* in "verbose" mode with a description of what changed from one
 
27
  version to the next
 
28
 
 
29
* with file-ids and revision-ids shown
 
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.
 
50
"""
 
51
 
 
52
 
 
53
# TODO: option to show delta summaries for merged-in revisions
 
54
import re
 
55
 
 
56
from bzrlib.delta import compare_trees
 
57
import bzrlib.errors as errors
 
58
from bzrlib.trace import mutter
 
59
from bzrlib.tree import EmptyTree
 
60
from bzrlib.tsort import merge_sort
 
61
 
 
62
 
 
63
def find_touching_revisions(branch, file_id):
 
64
    """Yield a description of revisions which affect the file_id.
 
65
 
 
66
    Each returned element is (revno, revision_id, description)
 
67
 
 
68
    This is the list of revisions where the file is either added,
 
69
    modified, renamed or deleted.
 
70
 
 
71
    TODO: Perhaps some way to limit this to only particular revisions,
 
72
    or to traverse a non-mainline set of revisions?
 
73
    """
 
74
    last_ie = None
 
75
    last_path = None
 
76
    revno = 1
 
77
    for revision_id in branch.revision_history():
 
78
        this_inv = branch.repository.get_revision_inventory(revision_id)
 
79
        if file_id in this_inv:
 
80
            this_ie = this_inv[file_id]
 
81
            this_path = this_inv.id2path(file_id)
 
82
        else:
 
83
            this_ie = this_path = None
 
84
 
 
85
        # now we know how it was last time, and how it is in this revision.
 
86
        # are those two states effectively the same or not?
 
87
 
 
88
        if not this_ie and not last_ie:
 
89
            # not present in either
 
90
            pass
 
91
        elif this_ie and not last_ie:
 
92
            yield revno, revision_id, "added " + this_path
 
93
        elif not this_ie and last_ie:
 
94
            # deleted here
 
95
            yield revno, revision_id, "deleted " + last_path
 
96
        elif this_path != last_path:
 
97
            yield revno, revision_id, ("renamed %s => %s" % (last_path, this_path))
 
98
        elif (this_ie.text_size != last_ie.text_size
 
99
              or this_ie.text_sha1 != last_ie.text_sha1):
 
100
            yield revno, revision_id, "modified " + this_path
 
101
 
 
102
        last_ie = this_ie
 
103
        last_path = this_path
 
104
        revno += 1
 
105
 
 
106
 
 
107
 
 
108
def _enumerate_history(branch):
 
109
    rh = []
 
110
    revno = 1
 
111
    for rev_id in branch.revision_history():
 
112
        rh.append((revno, rev_id))
 
113
        revno += 1
 
114
    return rh
 
115
 
 
116
 
 
117
def _get_revision_delta(branch, revno):
 
118
    """Return the delta for a mainline revision.
 
119
    
 
120
    This is used to show summaries in verbose logs, and also for finding 
 
121
    revisions which touch a given file."""
 
122
    # XXX: What are we supposed to do when showing a summary for something 
 
123
    # other than a mainline revision.  The delta to it's first parent, or
 
124
    # (more useful) the delta to a nominated other revision.
 
125
    return branch.get_revision_delta(revno)
 
126
 
 
127
 
 
128
def show_log(branch,
 
129
             lf,
 
130
             specific_fileid=None,
 
131
             verbose=False,
 
132
             direction='reverse',
 
133
             start_revision=None,
 
134
             end_revision=None,
 
135
             search=None):
 
136
    """Write out human-readable log of commits to this branch.
 
137
 
 
138
    lf
 
139
        LogFormatter object to show the output.
 
140
 
 
141
    specific_fileid
 
142
        If true, list only the commits affecting the specified
 
143
        file, rather than all commits.
 
144
 
 
145
    verbose
 
146
        If true show added/changed/deleted/renamed files.
 
147
 
 
148
    direction
 
149
        'reverse' (default) is latest to earliest;
 
150
        'forward' is earliest to latest.
 
151
 
 
152
    start_revision
 
153
        If not None, only show revisions >= start_revision
 
154
 
 
155
    end_revision
 
156
        If not None, only show revisions <= end_revision
 
157
    """
 
158
    branch.lock_read()
 
159
    try:
 
160
        _show_log(branch, lf, specific_fileid, verbose, direction,
 
161
                  start_revision, end_revision, search)
 
162
    finally:
 
163
        branch.unlock()
 
164
    
 
165
def _show_log(branch,
 
166
             lf,
 
167
             specific_fileid=None,
 
168
             verbose=False,
 
169
             direction='reverse',
 
170
             start_revision=None,
 
171
             end_revision=None,
 
172
             search=None):
 
173
    """Worker function for show_log - see show_log."""
 
174
    from bzrlib.osutils import format_date
 
175
    from bzrlib.errors import BzrCheckError
 
176
    from bzrlib.textui import show_status
 
177
    
 
178
    from warnings import warn
 
179
 
 
180
    if not isinstance(lf, LogFormatter):
 
181
        warn("not a LogFormatter instance: %r" % lf)
 
182
 
 
183
    if specific_fileid:
 
184
        mutter('get log for file_id %r', specific_fileid)
 
185
 
 
186
    if search is not None:
 
187
        import re
 
188
        searchRE = re.compile(search, re.IGNORECASE)
 
189
    else:
 
190
        searchRE = None
 
191
 
 
192
    which_revs = _enumerate_history(branch)
 
193
    
 
194
    if start_revision is None:
 
195
        start_revision = 1
 
196
    else:
 
197
        branch.check_real_revno(start_revision)
 
198
    
 
199
    if end_revision is None:
 
200
        end_revision = len(which_revs)
 
201
    else:
 
202
        branch.check_real_revno(end_revision)
 
203
 
 
204
    # list indexes are 0-based; revisions are 1-based
 
205
    cut_revs = which_revs[(start_revision-1):(end_revision)]
 
206
    if not cut_revs:
 
207
        return
 
208
    # override the mainline to look like the revision history.
 
209
    mainline_revs = [revision_id for index, revision_id in cut_revs]
 
210
    if cut_revs[0][0] == 1:
 
211
        mainline_revs.insert(0, None)
 
212
    else:
 
213
        mainline_revs.insert(0, which_revs[start_revision-2][1])
 
214
 
 
215
    merge_sorted_revisions = merge_sort(
 
216
        branch.repository.get_revision_graph(mainline_revs[-1]),
 
217
        mainline_revs[-1],
 
218
        mainline_revs)
 
219
 
 
220
    if direction == 'reverse':
 
221
        cut_revs.reverse()
 
222
    elif direction == 'forward':
 
223
        # forward means oldest first.
 
224
        merge_sorted_revisions.reverse()
 
225
    else:
 
226
        raise ValueError('invalid direction %r' % direction)
 
227
 
 
228
    revision_history = branch.revision_history()
 
229
 
 
230
    # convert the revision history to a dictionary:
 
231
    rev_nos = {}
 
232
    for index, rev_id in cut_revs:
 
233
        rev_nos[rev_id] = index
 
234
 
 
235
    # now we just print all the revisions
 
236
    for sequence, rev_id, merge_depth, end_of_merge in merge_sorted_revisions:
 
237
        rev = branch.repository.get_revision(rev_id)
 
238
 
 
239
        if searchRE:
 
240
            if not searchRE.search(rev.message):
 
241
                continue
 
242
 
 
243
        if merge_depth == 0:
 
244
            # a mainline revision.
 
245
            if verbose or specific_fileid:
 
246
                delta = _get_revision_delta(branch, rev_nos[rev_id])
 
247
                
 
248
            if specific_fileid:
 
249
                if not delta.touches_file_id(specific_fileid):
 
250
                    continue
 
251
    
 
252
            if not verbose:
 
253
                # although we calculated it, throw it away without display
 
254
                delta = None
 
255
 
 
256
            lf.show(rev_nos[rev_id], rev, delta)
 
257
        elif hasattr(lf, 'show_merge'):
 
258
            lf.show_merge(rev, merge_depth)
 
259
 
 
260
 
 
261
def deltas_for_log_dummy(branch, which_revs):
 
262
    """Return all the revisions without intermediate deltas.
 
263
 
 
264
    Useful for log commands that won't need the delta information.
 
265
    """
 
266
    
 
267
    for revno, revision_id in which_revs:
 
268
        yield revno, branch.get_revision(revision_id), None
 
269
 
 
270
 
 
271
def deltas_for_log_reverse(branch, which_revs):
 
272
    """Compute deltas for display in latest-to-earliest order.
 
273
 
 
274
    branch
 
275
        Branch to traverse
 
276
 
 
277
    which_revs
 
278
        Sequence of (revno, revision_id) for the subset of history to examine
 
279
 
 
280
    returns 
 
281
        Sequence of (revno, rev, delta)
 
282
 
 
283
    The delta is from the given revision to the next one in the
 
284
    sequence, which makes sense if the log is being displayed from
 
285
    newest to oldest.
 
286
    """
 
287
    last_revno = last_revision_id = last_tree = None
 
288
    for revno, revision_id in which_revs:
 
289
        this_tree = branch.revision_tree(revision_id)
 
290
        this_revision = branch.get_revision(revision_id)
 
291
        
 
292
        if last_revno:
 
293
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
294
 
 
295
        this_tree = EmptyTree(branch.get_root_id())
 
296
 
 
297
        last_revno = revno
 
298
        last_revision = this_revision
 
299
        last_tree = this_tree
 
300
 
 
301
    if last_revno:
 
302
        if last_revno == 1:
 
303
            this_tree = EmptyTree(branch.get_root_id())
 
304
        else:
 
305
            this_revno = last_revno - 1
 
306
            this_revision_id = branch.revision_history()[this_revno]
 
307
            this_tree = branch.revision_tree(this_revision_id)
 
308
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
309
 
 
310
 
 
311
def deltas_for_log_forward(branch, which_revs):
 
312
    """Compute deltas for display in forward log.
 
313
 
 
314
    Given a sequence of (revno, revision_id) pairs, return
 
315
    (revno, rev, delta).
 
316
 
 
317
    The delta is from the given revision to the next one in the
 
318
    sequence, which makes sense if the log is being displayed from
 
319
    newest to oldest.
 
320
    """
 
321
    last_revno = last_revision_id = last_tree = None
 
322
    prev_tree = EmptyTree(branch.get_root_id())
 
323
 
 
324
    for revno, revision_id in which_revs:
 
325
        this_tree = branch.revision_tree(revision_id)
 
326
        this_revision = branch.get_revision(revision_id)
 
327
 
 
328
        if not last_revno:
 
329
            if revno == 1:
 
330
                last_tree = EmptyTree(branch.get_root_id())
 
331
            else:
 
332
                last_revno = revno - 1
 
333
                last_revision_id = branch.revision_history()[last_revno]
 
334
                last_tree = branch.revision_tree(last_revision_id)
 
335
 
 
336
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
337
 
 
338
        last_revno = revno
 
339
        last_revision = this_revision
 
340
        last_tree = this_tree
 
341
 
 
342
 
 
343
class LogFormatter(object):
 
344
    """Abstract class to display log messages."""
 
345
 
 
346
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
347
        self.to_file = to_file
 
348
        self.show_ids = show_ids
 
349
        self.show_timezone = show_timezone
 
350
 
 
351
    def show(self, revno, rev, delta):
 
352
        raise NotImplementedError('not implemented in abstract base')
 
353
 
 
354
    def short_committer(self, rev):
 
355
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
 
356
    
 
357
    
 
358
class LongLogFormatter(LogFormatter):
 
359
    def show(self, revno, rev, delta):
 
360
        return self._show_helper(revno=revno, rev=rev, delta=delta)
 
361
 
 
362
    def show_merge(self, rev, merge_depth):
 
363
        return self._show_helper(rev=rev, indent='    '*merge_depth, merged=True, delta=None)
 
364
 
 
365
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
 
366
        """Show a revision, either merged or not."""
 
367
        from bzrlib.osutils import format_date
 
368
        to_file = self.to_file
 
369
        print >>to_file,  indent+'-' * 60
 
370
        if revno is not None:
 
371
            print >>to_file,  'revno:', revno
 
372
        if merged:
 
373
            print >>to_file,  indent+'merged:', rev.revision_id
 
374
        elif self.show_ids:
 
375
            print >>to_file,  indent+'revision-id:', rev.revision_id
 
376
        if self.show_ids:
 
377
            for parent_id in rev.parent_ids:
 
378
                print >>to_file, indent+'parent:', parent_id
 
379
        print >>to_file,  indent+'committer:', rev.committer
 
380
        try:
 
381
            print >>to_file, indent+'branch nick: %s' % \
 
382
                rev.properties['branch-nick']
 
383
        except KeyError:
 
384
            pass
 
385
        date_str = format_date(rev.timestamp,
 
386
                               rev.timezone or 0,
 
387
                               self.show_timezone)
 
388
        print >>to_file,  indent+'timestamp: %s' % date_str
 
389
 
 
390
        print >>to_file,  indent+'message:'
 
391
        if not rev.message:
 
392
            print >>to_file,  indent+'  (no message)'
 
393
        else:
 
394
            message = rev.message.rstrip('\r\n')
 
395
            for l in message.split('\n'):
 
396
                print >>to_file,  indent+'  ' + l
 
397
        if delta != None:
 
398
            delta.show(to_file, self.show_ids)
 
399
 
 
400
 
 
401
class ShortLogFormatter(LogFormatter):
 
402
    def show(self, revno, rev, delta):
 
403
        from bzrlib.osutils import format_date
 
404
 
 
405
        to_file = self.to_file
 
406
        date_str = format_date(rev.timestamp, rev.timezone or 0,
 
407
                            self.show_timezone)
 
408
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
 
409
                format_date(rev.timestamp, rev.timezone or 0,
 
410
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
411
                           show_offset=False))
 
412
        if self.show_ids:
 
413
            print >>to_file,  '      revision-id:', rev.revision_id
 
414
        if not rev.message:
 
415
            print >>to_file,  '      (no message)'
 
416
        else:
 
417
            message = rev.message.rstrip('\r\n')
 
418
            for l in message.split('\n'):
 
419
                print >>to_file,  '      ' + l
 
420
 
 
421
        # TODO: Why not show the modified files in a shorter form as
 
422
        # well? rewrap them single lines of appropriate length
 
423
        if delta != None:
 
424
            delta.show(to_file, self.show_ids)
 
425
        print >>to_file, ''
 
426
 
 
427
 
 
428
class LineLogFormatter(LogFormatter):
 
429
    def truncate(self, str, max_len):
 
430
        if len(str) <= max_len:
 
431
            return str
 
432
        return str[:max_len-3]+'...'
 
433
 
 
434
    def date_string(self, rev):
 
435
        from bzrlib.osutils import format_date
 
436
        return format_date(rev.timestamp, rev.timezone or 0, 
 
437
                           self.show_timezone, date_fmt="%Y-%m-%d",
 
438
                           show_offset=False)
 
439
 
 
440
    def message(self, rev):
 
441
        if not rev.message:
 
442
            return '(no message)'
 
443
        else:
 
444
            return rev.message
 
445
 
 
446
    def show(self, revno, rev, delta):
 
447
        from bzrlib.osutils import terminal_width
 
448
        print >> self.to_file, self.log_string(revno, rev, terminal_width()-1)
 
449
 
 
450
    def log_string(self, revno, rev, max_chars):
 
451
        """Format log info into one string. Truncate tail of string
 
452
        :param  revno:      revision number (int) or None.
 
453
                            Revision numbers counts from 1.
 
454
        :param  rev:        revision info object
 
455
        :param  max_chars:  maximum length of resulting string
 
456
        :return:            formatted truncated string
 
457
        """
 
458
        out = []
 
459
        if revno:
 
460
            # show revno only when is not None
 
461
            out.append("%d:" % revno)
 
462
        out.append(self.truncate(self.short_committer(rev), 20))
 
463
        out.append(self.date_string(rev))
 
464
        out.append(self.message(rev).replace('\n', ' '))
 
465
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
466
 
 
467
 
 
468
def line_log(rev, max_chars):
 
469
    lf = LineLogFormatter(None)
 
470
    return lf.log_string(None, rev, max_chars)
 
471
 
 
472
FORMATTERS = {
 
473
              'long': LongLogFormatter,
 
474
              'short': ShortLogFormatter,
 
475
              'line': LineLogFormatter,
 
476
              }
 
477
 
 
478
def register_formatter(name, formatter):
 
479
    FORMATTERS[name] = formatter
 
480
 
 
481
def log_formatter(name, *args, **kwargs):
 
482
    """Construct a formatter from arguments.
 
483
 
 
484
    name -- Name of the formatter to construct; currently 'long', 'short' and
 
485
        'line' are supported.
 
486
    """
 
487
    from bzrlib.errors import BzrCommandError
 
488
    try:
 
489
        return FORMATTERS[name](*args, **kwargs)
 
490
    except KeyError:
 
491
        raise BzrCommandError("unknown log formatter: %r" % name)
 
492
 
 
493
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
494
    # deprecated; for compatability
 
495
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
496
    lf.show(revno, rev, delta)
 
497
 
 
498
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
 
499
    """Show the change in revision history comparing the old revision history to the new one.
 
500
 
 
501
    :param branch: The branch where the revisions exist
 
502
    :param old_rh: The old revision history
 
503
    :param new_rh: The new revision history
 
504
    :param to_file: A file to write the results to. If None, stdout will be used
 
505
    """
 
506
    if to_file is None:
 
507
        import sys
 
508
        import codecs
 
509
        import bzrlib
 
510
        to_file = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
511
    lf = log_formatter(log_format,
 
512
                       show_ids=False,
 
513
                       to_file=to_file,
 
514
                       show_timezone='original')
 
515
 
 
516
    # This is the first index which is different between
 
517
    # old and new
 
518
    base_idx = None
 
519
    for i in xrange(max(len(new_rh),
 
520
                        len(old_rh))):
 
521
        if (len(new_rh) <= i
 
522
            or len(old_rh) <= i
 
523
            or new_rh[i] != old_rh[i]):
 
524
            base_idx = i
 
525
            break
 
526
 
 
527
    if base_idx is None:
 
528
        to_file.write('Nothing seems to have changed\n')
 
529
        return
 
530
    ## TODO: It might be nice to do something like show_log
 
531
    ##       and show the merged entries. But since this is the
 
532
    ##       removed revisions, it shouldn't be as important
 
533
    if base_idx < len(old_rh):
 
534
        to_file.write('*'*60)
 
535
        to_file.write('\nRemoved Revisions:\n')
 
536
        for i in range(base_idx, len(old_rh)):
 
537
            rev = branch.repository.get_revision(old_rh[i])
 
538
            lf.show(i+1, rev, None)
 
539
        to_file.write('*'*60)
 
540
        to_file.write('\n\n')
 
541
    if base_idx < len(new_rh):
 
542
        to_file.write('Added Revisions:\n')
 
543
        show_log(branch,
 
544
                 lf,
 
545
                 None,
 
546
                 verbose=True,
 
547
                 direction='forward',
 
548
                 start_revision=base_idx+1,
 
549
                 end_revision=len(new_rh),
 
550
                 search=None)
 
551