~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: mbp at sourcefrog
  • Date: 2005-04-11 02:44:45 UTC
  • Revision ID: mbp@sourcefrog.net-20050411024445-a2d4fa7e39309d2300533a6a
- Experiments in inventory performance

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
 
from bzrlib.tree import EmptyTree
54
 
from bzrlib.delta import compare_trees
55
 
from bzrlib.trace import mutter
56
 
 
57
 
 
58
 
def find_touching_revisions(branch, file_id):
59
 
    """Yield a description of revisions which affect the file_id.
60
 
 
61
 
    Each returned element is (revno, revision_id, description)
62
 
 
63
 
    This is the list of revisions where the file is either added,
64
 
    modified, renamed or deleted.
65
 
 
66
 
    TODO: Perhaps some way to limit this to only particular revisions,
67
 
    or to traverse a non-mainline set of revisions?
68
 
    """
69
 
    last_ie = None
70
 
    last_path = None
71
 
    revno = 1
72
 
    for revision_id in branch.revision_history():
73
 
        this_inv = branch.get_revision_inventory(revision_id)
74
 
        if file_id in this_inv:
75
 
            this_ie = this_inv[file_id]
76
 
            this_path = this_inv.id2path(file_id)
77
 
        else:
78
 
            this_ie = this_path = None
79
 
 
80
 
        # now we know how it was last time, and how it is in this revision.
81
 
        # are those two states effectively the same or not?
82
 
 
83
 
        if not this_ie and not last_ie:
84
 
            # not present in either
85
 
            pass
86
 
        elif this_ie and not last_ie:
87
 
            yield revno, revision_id, "added " + this_path
88
 
        elif not this_ie and last_ie:
89
 
            # deleted here
90
 
            yield revno, revision_id, "deleted " + last_path
91
 
        elif this_path != last_path:
92
 
            yield revno, revision_id, ("renamed %s => %s" % (last_path, this_path))
93
 
        elif (this_ie.text_size != last_ie.text_size
94
 
              or this_ie.text_sha1 != last_ie.text_sha1):
95
 
            yield revno, revision_id, "modified " + this_path
96
 
 
97
 
        last_ie = this_ie
98
 
        last_path = this_path
99
 
        revno += 1
100
 
 
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 show_log(branch,
113
 
             lf,
114
 
             specific_fileid=None,
115
 
             verbose=False,
116
 
             direction='reverse',
117
 
             start_revision=None,
118
 
             end_revision=None,
119
 
             search=None):
120
 
    """Write out human-readable log of commits to this branch.
121
 
 
122
 
    lf
123
 
        LogFormatter object to show the output.
124
 
 
125
 
    specific_fileid
126
 
        If true, list only the commits affecting the specified
127
 
        file, rather than all commits.
128
 
 
129
 
    verbose
130
 
        If true show added/changed/deleted/renamed files.
131
 
 
132
 
    direction
133
 
        'reverse' (default) is latest to earliest;
134
 
        'forward' is earliest to latest.
135
 
 
136
 
    start_revision
137
 
        If not None, only show revisions >= start_revision
138
 
 
139
 
    end_revision
140
 
        If not None, only show revisions <= end_revision
141
 
    """
142
 
    from bzrlib.osutils import format_date
143
 
    from bzrlib.errors import BzrCheckError
144
 
    from bzrlib.textui import show_status
145
 
    
146
 
    from warnings import warn
147
 
 
148
 
    if not isinstance(lf, LogFormatter):
149
 
        warn("not a LogFormatter instance: %r" % lf)
150
 
 
151
 
    if specific_fileid:
152
 
        mutter('get log for file_id %r' % specific_fileid)
153
 
 
154
 
    if search is not None:
155
 
        import re
156
 
        searchRE = re.compile(search, re.IGNORECASE)
157
 
    else:
158
 
        searchRE = None
159
 
 
160
 
    which_revs = _enumerate_history(branch)
161
 
    
162
 
    if start_revision is None:
163
 
        start_revision = 1
164
 
    else:
165
 
        branch.check_real_revno(start_revision)
166
 
    
167
 
    if end_revision is None:
168
 
        end_revision = len(which_revs)
169
 
    else:
170
 
        branch.check_real_revno(end_revision)
171
 
 
172
 
    # list indexes are 0-based; revisions are 1-based
173
 
    cut_revs = which_revs[(start_revision-1):(end_revision)]
174
 
 
175
 
    if direction == 'reverse':
176
 
        cut_revs.reverse()
177
 
    elif direction == 'forward':
178
 
        pass
179
 
    else:
180
 
        raise ValueError('invalid direction %r' % direction)
181
 
 
182
 
    for revno, rev_id in cut_revs:
183
 
        if verbose or specific_fileid:
184
 
            delta = branch.get_revision_delta(revno)
185
 
            
186
 
        if specific_fileid:
187
 
            if not delta.touches_file_id(specific_fileid):
188
 
                continue
189
 
 
190
 
        if not verbose:
191
 
            # although we calculated it, throw it away without display
192
 
            delta = None
193
 
 
194
 
        rev = branch.get_revision(rev_id)
195
 
 
196
 
        if searchRE:
197
 
            if not searchRE.search(rev.message):
198
 
                continue
199
 
 
200
 
        lf.show(revno, rev, delta)
201
 
 
202
 
 
203
 
 
204
 
def deltas_for_log_dummy(branch, which_revs):
205
 
    """Return all the revisions without intermediate deltas.
206
 
 
207
 
    Useful for log commands that won't need the delta information.
208
 
    """
209
 
    
210
 
    for revno, revision_id in which_revs:
211
 
        yield revno, branch.get_revision(revision_id), None
212
 
 
213
 
 
214
 
def deltas_for_log_reverse(branch, which_revs):
215
 
    """Compute deltas for display in latest-to-earliest order.
216
 
 
217
 
    branch
218
 
        Branch to traverse
219
 
 
220
 
    which_revs
221
 
        Sequence of (revno, revision_id) for the subset of history to examine
222
 
 
223
 
    returns 
224
 
        Sequence of (revno, rev, delta)
225
 
 
226
 
    The delta is from the given revision to the next one in the
227
 
    sequence, which makes sense if the log is being displayed from
228
 
    newest to oldest.
229
 
    """
230
 
    last_revno = last_revision_id = last_tree = None
231
 
    for revno, revision_id in which_revs:
232
 
        this_tree = branch.revision_tree(revision_id)
233
 
        this_revision = branch.get_revision(revision_id)
234
 
        
235
 
        if last_revno:
236
 
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
237
 
 
238
 
        this_tree = EmptyTree(branch.get_root_id())
239
 
 
240
 
        last_revno = revno
241
 
        last_revision = this_revision
242
 
        last_tree = this_tree
243
 
 
244
 
    if last_revno:
245
 
        if last_revno == 1:
246
 
            this_tree = EmptyTree(branch.get_root_id())
247
 
        else:
248
 
            this_revno = last_revno - 1
249
 
            this_revision_id = branch.revision_history()[this_revno]
250
 
            this_tree = branch.revision_tree(this_revision_id)
251
 
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
252
 
 
253
 
 
254
 
def deltas_for_log_forward(branch, which_revs):
255
 
    """Compute deltas for display in forward log.
256
 
 
257
 
    Given a sequence of (revno, revision_id) pairs, return
258
 
    (revno, rev, delta).
259
 
 
260
 
    The delta is from the given revision to the next one in the
261
 
    sequence, which makes sense if the log is being displayed from
262
 
    newest to oldest.
263
 
    """
264
 
    last_revno = last_revision_id = last_tree = None
265
 
    prev_tree = EmptyTree(branch.get_root_id())
266
 
 
267
 
    for revno, revision_id in which_revs:
268
 
        this_tree = branch.revision_tree(revision_id)
269
 
        this_revision = branch.get_revision(revision_id)
270
 
 
271
 
        if not last_revno:
272
 
            if revno == 1:
273
 
                last_tree = EmptyTree(branch.get_root_id())
274
 
            else:
275
 
                last_revno = revno - 1
276
 
                last_revision_id = branch.revision_history()[last_revno]
277
 
                last_tree = branch.revision_tree(last_revision_id)
278
 
 
279
 
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
280
 
 
281
 
        last_revno = revno
282
 
        last_revision = this_revision
283
 
        last_tree = this_tree
284
 
 
285
 
 
286
 
class LogFormatter(object):
287
 
    """Abstract class to display log messages."""
288
 
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
289
 
        self.to_file = to_file
290
 
        self.show_ids = show_ids
291
 
        self.show_timezone = show_timezone
292
 
 
293
 
 
294
 
    def show(self, revno, rev, delta):
295
 
        raise NotImplementedError('not implemented in abstract base')
296
 
        
297
 
 
298
 
 
299
 
 
300
 
 
301
 
 
302
 
class LongLogFormatter(LogFormatter):
303
 
    def show(self, revno, rev, delta):
304
 
        from osutils import format_date
305
 
 
306
 
        to_file = self.to_file
307
 
 
308
 
        print >>to_file,  '-' * 60
309
 
        print >>to_file,  'revno:', revno
310
 
        if self.show_ids:
311
 
            print >>to_file,  'revision-id:', rev.revision_id
312
 
 
313
 
            for parent in rev.parents:
314
 
                print >>to_file, 'parent:', parent.revision_id
315
 
            
316
 
        print >>to_file,  'committer:', rev.committer
317
 
 
318
 
        date_str = format_date(rev.timestamp,
319
 
                               rev.timezone or 0,
320
 
                               self.show_timezone)
321
 
        print >>to_file,  'timestamp: %s' % date_str
322
 
 
323
 
        print >>to_file,  'message:'
324
 
        if not rev.message:
325
 
            print >>to_file,  '  (no message)'
326
 
        else:
327
 
            for l in rev.message.split('\n'):
328
 
                print >>to_file,  '  ' + l
329
 
 
330
 
        if delta != None:
331
 
            delta.show(to_file, self.show_ids)
332
 
 
333
 
 
334
 
 
335
 
class ShortLogFormatter(LogFormatter):
336
 
    def show(self, revno, rev, delta):
337
 
        from bzrlib.osutils import format_date
338
 
 
339
 
        to_file = self.to_file
340
 
 
341
 
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
342
 
                format_date(rev.timestamp, rev.timezone or 0,
343
 
                            self.show_timezone))
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
 
            for l in rev.message.split('\n'):
350
 
                print >>to_file,  '      ' + l
351
 
 
352
 
        # TODO: Why not show the modified files in a shorter form as
353
 
        # well? rewrap them single lines of appropriate length
354
 
        if delta != None:
355
 
            delta.show(to_file, self.show_ids)
356
 
        print
357
 
 
358
 
 
359
 
 
360
 
FORMATTERS = {'long': LongLogFormatter,
361
 
              'short': ShortLogFormatter,
362
 
              }
363
 
 
364
 
 
365
 
def log_formatter(name, *args, **kwargs):
366
 
    from bzrlib.errors import BzrCommandError
367
 
    
368
 
    try:
369
 
        return FORMATTERS[name](*args, **kwargs)
370
 
    except IndexError:
371
 
        raise BzrCommandError("unknown log formatter: %r" % name)
372
 
 
373
 
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
374
 
    # deprecated; for compatability
375
 
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
376
 
    lf.show(revno, rev, delta)