← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

merge bzr.dev

Show diffs side-by-side

added added

removed removed

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