~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Martin Pool
  • Date: 2005-05-02 04:24:33 UTC
  • Revision ID: mbp@sourcefrog.net-20050502042433-c825a7f7235f6b15
doc: notes on merge

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
 
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
 
 
58
 
 
59
 
def find_touching_revisions(branch, file_id):
60
 
    """Yield a description of revisions which affect the file_id.
61
 
 
62
 
    Each returned element is (revno, revision_id, description)
63
 
 
64
 
    This is the list of revisions where the file is either added,
65
 
    modified, renamed or deleted.
66
 
 
67
 
    TODO: Perhaps some way to limit this to only particular revisions,
68
 
    or to traverse a non-mainline set of revisions?
69
 
    """
70
 
    last_ie = None
71
 
    last_path = None
72
 
    revno = 1
73
 
    for revision_id in branch.revision_history():
74
 
        this_inv = branch.get_revision_inventory(revision_id)
75
 
        if file_id in this_inv:
76
 
            this_ie = this_inv[file_id]
77
 
            this_path = this_inv.id2path(file_id)
78
 
        else:
79
 
            this_ie = this_path = None
80
 
 
81
 
        # now we know how it was last time, and how it is in this revision.
82
 
        # are those two states effectively the same or not?
83
 
 
84
 
        if not this_ie and not last_ie:
85
 
            # not present in either
86
 
            pass
87
 
        elif this_ie and not last_ie:
88
 
            yield revno, revision_id, "added " + this_path
89
 
        elif not this_ie and last_ie:
90
 
            # deleted here
91
 
            yield revno, revision_id, "deleted " + last_path
92
 
        elif this_path != last_path:
93
 
            yield revno, revision_id, ("renamed %s => %s" % (last_path, this_path))
94
 
        elif (this_ie.text_size != last_ie.text_size
95
 
              or this_ie.text_sha1 != last_ie.text_sha1):
96
 
            yield revno, revision_id, "modified " + this_path
97
 
 
98
 
        last_ie = this_ie
99
 
        last_path = this_path
100
 
        revno += 1
101
 
 
102
 
 
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
 
 
124
 
def show_log(branch,
125
 
             lf,
126
 
             specific_fileid=None,
127
 
             verbose=False,
128
 
             direction='reverse',
129
 
             start_revision=None,
130
 
             end_revision=None,
131
 
             search=None):
132
 
    """Write out human-readable log of commits to this branch.
133
 
 
134
 
    lf
135
 
        LogFormatter object to show the output.
136
 
 
137
 
    specific_fileid
138
 
        If true, list only the commits affecting the specified
139
 
        file, rather than all commits.
140
 
 
141
 
    verbose
142
 
        If true show added/changed/deleted/renamed files.
143
 
 
144
 
    direction
145
 
        'reverse' (default) is latest to earliest;
146
 
        'forward' is earliest to latest.
147
 
 
148
 
    start_revision
149
 
        If not None, only show revisions >= start_revision
150
 
 
151
 
    end_revision
152
 
        If not None, only show revisions <= end_revision
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."""
170
 
    from bzrlib.osutils import format_date
171
 
    from bzrlib.errors import BzrCheckError
172
 
    from bzrlib.textui import show_status
173
 
    
174
 
    from warnings import warn
175
 
 
176
 
    if not isinstance(lf, LogFormatter):
177
 
        warn("not a LogFormatter instance: %r" % lf)
178
 
 
179
 
    if specific_fileid:
180
 
        mutter('get log for file_id %r' % specific_fileid)
181
 
 
182
 
    if search is not None:
183
 
        import re
184
 
        searchRE = re.compile(search, re.IGNORECASE)
185
 
    else:
186
 
        searchRE = None
187
 
 
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
 
            
215
 
        if specific_fileid:
216
 
            if not delta.touches_file_id(specific_fileid):
217
 
                continue
218
 
 
219
 
        if not verbose:
220
 
            # although we calculated it, throw it away without display
221
 
            delta = None
222
 
 
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)
248
 
 
249
 
 
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
 
    
256
 
    for revno, revision_id in which_revs:
257
 
        yield revno, branch.get_revision(revision_id), None
258
 
 
259
 
 
260
 
def deltas_for_log_reverse(branch, which_revs):
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)
271
 
 
272
 
    The delta is from the given revision to the next one in the
273
 
    sequence, which makes sense if the log is being displayed from
274
 
    newest to oldest.
275
 
    """
276
 
    last_revno = last_revision_id = last_tree = None
277
 
    for revno, revision_id in which_revs:
278
 
        this_tree = branch.revision_tree(revision_id)
279
 
        this_revision = branch.get_revision(revision_id)
280
 
        
281
 
        if last_revno:
282
 
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
283
 
 
284
 
        this_tree = EmptyTree(branch.get_root_id())
285
 
 
286
 
        last_revno = revno
287
 
        last_revision = this_revision
288
 
        last_tree = this_tree
289
 
 
290
 
    if last_revno:
291
 
        if last_revno == 1:
292
 
            this_tree = EmptyTree(branch.get_root_id())
293
 
        else:
294
 
            this_revno = last_revno - 1
295
 
            this_revision_id = branch.revision_history()[this_revno]
296
 
            this_tree = branch.revision_tree(this_revision_id)
297
 
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
298
 
 
299
 
 
300
 
def deltas_for_log_forward(branch, which_revs):
301
 
    """Compute deltas for display in forward log.
302
 
 
303
 
    Given a sequence of (revno, revision_id) pairs, return
304
 
    (revno, rev, delta).
305
 
 
306
 
    The delta is from the given revision to the next one in the
307
 
    sequence, which makes sense if the log is being displayed from
308
 
    newest to oldest.
309
 
    """
310
 
    last_revno = last_revision_id = last_tree = None
311
 
    prev_tree = EmptyTree(branch.get_root_id())
312
 
 
313
 
    for revno, revision_id in which_revs:
314
 
        this_tree = branch.revision_tree(revision_id)
315
 
        this_revision = branch.get_revision(revision_id)
316
 
 
317
 
        if not last_revno:
318
 
            if revno == 1:
319
 
                last_tree = EmptyTree(branch.get_root_id())
320
 
            else:
321
 
                last_revno = revno - 1
322
 
                last_revision_id = branch.revision_history()[last_revno]
323
 
                last_tree = branch.revision_tree(last_revision_id)
324
 
 
325
 
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
326
 
 
327
 
        last_revno = revno
328
 
        last_revision = this_revision
329
 
        last_tree = this_tree
330
 
 
331
 
 
332
 
class LogFormatter(object):
333
 
    """Abstract class to display log messages."""
334
 
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
335
 
        self.to_file = to_file
336
 
        self.show_ids = show_ids
337
 
        self.show_timezone = show_timezone
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
 
    
347
 
class LongLogFormatter(LogFormatter):
348
 
    def show(self, revno, rev, delta):
349
 
        from osutils import format_date
350
 
 
351
 
        to_file = self.to_file
352
 
 
353
 
        print >>to_file,  '-' * 60
354
 
        print >>to_file,  'revno:', revno
355
 
        if self.show_ids:
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
 
            
361
 
        print >>to_file,  'committer:', rev.committer
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
367
 
 
368
 
        print >>to_file,  'message:'
369
 
        if not rev.message:
370
 
            print >>to_file,  '  (no message)'
371
 
        else:
372
 
            for l in rev.message.split('\n'):
373
 
                print >>to_file,  '  ' + l
374
 
 
375
 
        if delta != None:
376
 
            delta.show(to_file, self.show_ids)
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
404
 
 
405
 
 
406
 
class ShortLogFormatter(LogFormatter):
407
 
    def show(self, revno, rev, delta):
408
 
        from bzrlib.osutils import format_date
409
 
 
410
 
        to_file = self.to_file
411
 
 
412
 
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
413
 
                format_date(rev.timestamp, rev.timezone or 0,
414
 
                            self.show_timezone))
415
 
        if self.show_ids:
416
 
            print >>to_file,  '      revision-id:', rev.revision_id
417
 
        if not rev.message:
418
 
            print >>to_file,  '      (no message)'
419
 
        else:
420
 
            for l in rev.message.split('\n'):
421
 
                print >>to_file,  '      ' + l
422
 
 
423
 
        # TODO: Why not show the modified files in a shorter form as
424
 
        # well? rewrap them single lines of appropriate length
425
 
        if delta != None:
426
 
            delta.show(to_file, self.show_ids)
427
 
        print
428
 
 
429
 
 
430
 
 
431
 
FORMATTERS = {'long': LongLogFormatter,
432
 
              'short': ShortLogFormatter,
433
 
              }
434
 
 
435
 
 
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
 
    """
442
 
    from bzrlib.errors import BzrCommandError
443
 
    try:
444
 
        return FORMATTERS[name](*args, **kwargs)
445
 
    except IndexError:
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)