← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Robert Collins
  • Date: 2005-10-06 12:14:01 UTC
  • mfrom: (1393.1.67)
  • Revision ID: robertc@robertcollins.net-20051006121401-ce87bcb93909bbdf
merge martins latest

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
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
 
 
53
from bzrlib.tree import EmptyTree
 
54
from bzrlib.delta import compare_trees
 
55
from bzrlib.trace import mutter
 
56
 
19
57
 
20
58
def find_touching_revisions(branch, file_id):
21
59
    """Yield a description of revisions which affect the file_id.
25
63
    This is the list of revisions where the file is either added,
26
64
    modified, renamed or deleted.
27
65
 
28
 
    Revisions are returned in chronological order.
29
 
 
30
66
    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.
 
67
    or to traverse a non-mainline set of revisions?
35
68
    """
36
69
    last_ie = None
37
70
    last_path = None
66
99
        revno += 1
67
100
 
68
101
 
 
102
 
 
103
def _enumerate_history(branch):
 
104
    rh = []
 
105
    revno = 1
 
106
    for rev_id in branch.revision_history():
 
107
        rh.append((revno, rev_id))
 
108
        revno += 1
 
109
    return rh
 
110
 
 
111
 
 
112
def _get_revision_delta(branch, revno):
 
113
    """Return the delta for a mainline revision.
 
114
    
 
115
    This is used to show summaries in verbose logs, and also for finding 
 
116
    revisions which touch a given file."""
 
117
    # FIXME: The current version is very inefficient; it retrieves all revisions
 
118
    # twice and reads the weave twice.  We ought to keep revisions in memory 
 
119
    # in case they're used again, either in a general cache or perhaps 
 
120
    # in this code.
 
121
    # XXX: What are we supposed to do when showing a summary for something 
 
122
    # other than a mainline revision.  The delta to it's first parent, or
 
123
    # (more useful) the delta to a nominated other revision.
 
124
    return branch.get_revision_delta(revno)
 
125
 
 
126
 
69
127
def show_log(branch,
70
 
             filename=None,
71
 
             show_timezone='original',
 
128
             lf,
 
129
             specific_fileid=None,
72
130
             verbose=False,
73
 
             show_ids=False,
74
 
             to_file=None):
 
131
             direction='reverse',
 
132
             start_revision=None,
 
133
             end_revision=None,
 
134
             search=None):
75
135
    """Write out human-readable log of commits to this branch.
76
136
 
77
 
    filename
 
137
    lf
 
138
        LogFormatter object to show the output.
 
139
 
 
140
    specific_fileid
78
141
        If true, list only the commits affecting the specified
79
142
        file, rather than all commits.
80
143
 
81
 
    show_timezone
82
 
        'original' (committer's timezone),
83
 
        'utc' (universal time), or
84
 
        'local' (local user's timezone)
85
 
 
86
144
    verbose
87
145
        If true show added/changed/deleted/renamed files.
88
146
 
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_trees
98
 
    from textui import show_status
99
 
 
100
 
    if to_file == None:
101
 
        import sys
102
 
        to_file = sys.stdout
103
 
 
104
 
    if filename:
105
 
        file_id = branch.read_working_inventory().path2id(filename)
106
 
        def which_revs():
107
 
            for revno, revid, why in find_touching_revisions(branch, file_id):
108
 
                yield revno, revid
109
 
    else:
110
 
        def which_revs():
111
 
            for i, revid in enumerate(branch.revision_history()):
112
 
                yield i+1, revid
 
147
    direction
 
148
        'reverse' (default) is latest to earliest;
 
149
        'forward' is earliest to latest.
 
150
 
 
151
    start_revision
 
152
        If not None, only show revisions >= start_revision
 
153
 
 
154
    end_revision
 
155
        If not None, only show revisions <= end_revision
 
156
    """
 
157
    from bzrlib.osutils import format_date
 
158
    from bzrlib.errors import BzrCheckError
 
159
    from bzrlib.textui import show_status
 
160
    
 
161
    from warnings import warn
 
162
 
 
163
    if not isinstance(lf, LogFormatter):
 
164
        warn("not a LogFormatter instance: %r" % lf)
 
165
 
 
166
    if specific_fileid:
 
167
        mutter('get log for file_id %r' % specific_fileid)
 
168
 
 
169
    if search is not None:
 
170
        import re
 
171
        searchRE = re.compile(search, re.IGNORECASE)
 
172
    else:
 
173
        searchRE = None
 
174
 
 
175
    which_revs = _enumerate_history(branch)
 
176
    
 
177
    if start_revision is None:
 
178
        start_revision = 1
 
179
    else:
 
180
        branch.check_real_revno(start_revision)
 
181
    
 
182
    if end_revision is None:
 
183
        end_revision = len(which_revs)
 
184
    else:
 
185
        branch.check_real_revno(end_revision)
 
186
 
 
187
    # list indexes are 0-based; revisions are 1-based
 
188
    cut_revs = which_revs[(start_revision-1):(end_revision)]
 
189
 
 
190
    if direction == 'reverse':
 
191
        cut_revs.reverse()
 
192
    elif direction == 'forward':
 
193
        pass
 
194
    else:
 
195
        raise ValueError('invalid direction %r' % direction)
 
196
 
 
197
    for revno, rev_id in cut_revs:
 
198
        if verbose or specific_fileid:
 
199
            delta = _get_revision_delta(branch, revno)
 
200
            
 
201
        if specific_fileid:
 
202
            if not delta.touches_file_id(specific_fileid):
 
203
                continue
 
204
 
 
205
        if not verbose:
 
206
            # although we calculated it, throw it away without display
 
207
            delta = None
 
208
 
 
209
        rev = branch.get_revision(rev_id)
 
210
 
 
211
        if searchRE:
 
212
            if not searchRE.search(rev.message):
 
213
                continue
 
214
 
 
215
        lf.show(revno, rev, delta)
 
216
 
 
217
 
 
218
 
 
219
def deltas_for_log_dummy(branch, which_revs):
 
220
    """Return all the revisions without intermediate deltas.
 
221
 
 
222
    Useful for log commands that won't need the delta information.
 
223
    """
 
224
    
 
225
    for revno, revision_id in which_revs:
 
226
        yield revno, branch.get_revision(revision_id), None
 
227
 
 
228
 
 
229
def deltas_for_log_reverse(branch, which_revs):
 
230
    """Compute deltas for display in latest-to-earliest order.
 
231
 
 
232
    branch
 
233
        Branch to traverse
 
234
 
 
235
    which_revs
 
236
        Sequence of (revno, revision_id) for the subset of history to examine
 
237
 
 
238
    returns 
 
239
        Sequence of (revno, rev, delta)
 
240
 
 
241
    The delta is from the given revision to the next one in the
 
242
    sequence, which makes sense if the log is being displayed from
 
243
    newest to oldest.
 
244
    """
 
245
    last_revno = last_revision_id = last_tree = None
 
246
    for revno, revision_id in which_revs:
 
247
        this_tree = branch.revision_tree(revision_id)
 
248
        this_revision = branch.get_revision(revision_id)
113
249
        
114
 
    branch._need_readlock()
115
 
    precursor = None
116
 
    if verbose:
117
 
        from tree import EmptyTree
118
 
        prev_tree = EmptyTree()
119
 
    for revno, revision_id in which_revs():
 
250
        if last_revno:
 
251
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
252
 
 
253
        this_tree = EmptyTree(branch.get_root_id())
 
254
 
 
255
        last_revno = revno
 
256
        last_revision = this_revision
 
257
        last_tree = this_tree
 
258
 
 
259
    if last_revno:
 
260
        if last_revno == 1:
 
261
            this_tree = EmptyTree(branch.get_root_id())
 
262
        else:
 
263
            this_revno = last_revno - 1
 
264
            this_revision_id = branch.revision_history()[this_revno]
 
265
            this_tree = branch.revision_tree(this_revision_id)
 
266
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
267
 
 
268
 
 
269
def deltas_for_log_forward(branch, which_revs):
 
270
    """Compute deltas for display in forward log.
 
271
 
 
272
    Given a sequence of (revno, revision_id) pairs, return
 
273
    (revno, rev, delta).
 
274
 
 
275
    The delta is from the given revision to the next one in the
 
276
    sequence, which makes sense if the log is being displayed from
 
277
    newest to oldest.
 
278
    """
 
279
    last_revno = last_revision_id = last_tree = None
 
280
    prev_tree = EmptyTree(branch.get_root_id())
 
281
 
 
282
    for revno, revision_id in which_revs:
 
283
        this_tree = branch.revision_tree(revision_id)
 
284
        this_revision = branch.get_revision(revision_id)
 
285
 
 
286
        if not last_revno:
 
287
            if revno == 1:
 
288
                last_tree = EmptyTree(branch.get_root_id())
 
289
            else:
 
290
                last_revno = revno - 1
 
291
                last_revision_id = branch.revision_history()[last_revno]
 
292
                last_tree = branch.revision_tree(last_revision_id)
 
293
 
 
294
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
295
 
 
296
        last_revno = revno
 
297
        last_revision = this_revision
 
298
        last_tree = this_tree
 
299
 
 
300
 
 
301
class LogFormatter(object):
 
302
    """Abstract class to display log messages."""
 
303
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
304
        self.to_file = to_file
 
305
        self.show_ids = show_ids
 
306
        self.show_timezone = show_timezone
 
307
 
 
308
 
 
309
    def show(self, revno, rev, delta):
 
310
        raise NotImplementedError('not implemented in abstract base')
 
311
 
 
312
    
 
313
class LongLogFormatter(LogFormatter):
 
314
    def show(self, revno, rev, delta):
 
315
        from osutils import format_date
 
316
 
 
317
        to_file = self.to_file
 
318
 
120
319
        print >>to_file,  '-' * 60
121
320
        print >>to_file,  'revno:', revno
122
 
        rev = branch.get_revision(revision_id)
123
 
        if show_ids:
124
 
            print >>to_file,  'revision-id:', revision_id
 
321
        if self.show_ids:
 
322
            print >>to_file,  'revision-id:', rev.revision_id
 
323
 
 
324
            for parent_id in rev.parent_ids:
 
325
                print >>to_file, 'parent:', parent_id
 
326
            
125
327
        print >>to_file,  'committer:', rev.committer
126
 
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
127
 
                                             show_timezone))
128
328
 
129
 
        if revision_id != rev.revision_id:
130
 
            raise BzrCheckError("retrieved wrong revision: %r"
131
 
                                % (revision_id, rev.revision_id))
 
329
        date_str = format_date(rev.timestamp,
 
330
                               rev.timezone or 0,
 
331
                               self.show_timezone)
 
332
        print >>to_file,  'timestamp: %s' % date_str
132
333
 
133
334
        print >>to_file,  'message:'
134
335
        if not rev.message:
137
338
            for l in rev.message.split('\n'):
138
339
                print >>to_file,  '  ' + l
139
340
 
140
 
        # Don't show a list of changed files if we were asked about
141
 
        # one specific file.
142
 
 
143
 
        if verbose:
144
 
            this_tree = branch.revision_tree(revision_id)
145
 
            delta = compare_trees(prev_tree, this_tree, want_unchanged=False)
146
 
            delta.show(to_file, show_ids)
147
 
            prev_tree = this_tree
148
 
 
149
 
        precursor = revision_id
150
 
 
 
341
        if delta != None:
 
342
            delta.show(to_file, self.show_ids)
 
343
 
 
344
 
 
345
 
 
346
class ShortLogFormatter(LogFormatter):
 
347
    def show(self, revno, rev, delta):
 
348
        from bzrlib.osutils import format_date
 
349
 
 
350
        to_file = self.to_file
 
351
 
 
352
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
 
353
                format_date(rev.timestamp, rev.timezone or 0,
 
354
                            self.show_timezone))
 
355
        if self.show_ids:
 
356
            print >>to_file,  '      revision-id:', rev.revision_id
 
357
        if not rev.message:
 
358
            print >>to_file,  '      (no message)'
 
359
        else:
 
360
            for l in rev.message.split('\n'):
 
361
                print >>to_file,  '      ' + l
 
362
 
 
363
        # TODO: Why not show the modified files in a shorter form as
 
364
        # well? rewrap them single lines of appropriate length
 
365
        if delta != None:
 
366
            delta.show(to_file, self.show_ids)
 
367
        print
 
368
 
 
369
 
 
370
 
 
371
FORMATTERS = {'long': LongLogFormatter,
 
372
              'short': ShortLogFormatter,
 
373
              }
 
374
 
 
375
 
 
376
def log_formatter(name, *args, **kwargs):
 
377
    """Construct a formatter from arguments.
 
378
 
 
379
    name -- Name of the formatter to construct; currently 'long' and
 
380
        'short' are supported.
 
381
    """
 
382
    from bzrlib.errors import BzrCommandError
 
383
    try:
 
384
        return FORMATTERS[name](*args, **kwargs)
 
385
    except IndexError:
 
386
        raise BzrCommandError("unknown log formatter: %r" % name)
 
387
 
 
388
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
389
    # deprecated; for compatability
 
390
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
391
    lf.show(revno, rev, delta)