~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Robert Collins
  • Date: 2005-10-08 08:45:42 UTC
  • Revision ID: robertc@robertcollins.net-20051008084542-48ea5a99756f970e
add rm alias to remove

Show diffs side-by-side

added added

removed removed

Lines of Context:
28
28
 
29
29
* with file-ids and revision-ids shown
30
30
 
31
 
* from last to first or (not anymore) from first to last;
32
 
  the default is "reversed" because it shows the likely most
33
 
  relevant and interesting information first
34
 
 
35
 
* (not yet) in XML format
 
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.
36
50
"""
37
51
 
38
52
 
39
 
from trace import mutter
 
53
from bzrlib.tree import EmptyTree
 
54
from bzrlib.delta import compare_trees
 
55
from bzrlib.trace import mutter
 
56
 
40
57
 
41
58
def find_touching_revisions(branch, file_id):
42
59
    """Yield a description of revisions which affect the file_id.
83
100
 
84
101
 
85
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
    # XXX: What are we supposed to do when showing a summary for something 
 
118
    # other than a mainline revision.  The delta to it's first parent, or
 
119
    # (more useful) the delta to a nominated other revision.
 
120
    return branch.get_revision_delta(revno)
 
121
 
 
122
 
86
123
def show_log(branch,
87
124
             lf,
88
125
             specific_fileid=None,
113
150
    end_revision
114
151
        If not None, only show revisions <= end_revision
115
152
    """
 
153
    branch.lock_read()
 
154
    try:
 
155
        _show_log(branch, lf, specific_fileid, verbose, direction,
 
156
                  start_revision, end_revision, search)
 
157
    finally:
 
158
        branch.unlock()
 
159
    
 
160
def _show_log(branch,
 
161
             lf,
 
162
             specific_fileid=None,
 
163
             verbose=False,
 
164
             direction='reverse',
 
165
             start_revision=None,
 
166
             end_revision=None,
 
167
             search=None):
 
168
    """Worker function for show_log - see show_log."""
116
169
    from bzrlib.osutils import format_date
117
170
    from bzrlib.errors import BzrCheckError
118
171
    from bzrlib.textui import show_status
131
184
    else:
132
185
        searchRE = None
133
186
 
134
 
    which_revs = branch.enum_history(direction)
135
 
    which_revs = [x for x in which_revs if (
136
 
            (start_revision is None or x[0] >= start_revision)
137
 
            and (end_revision is None or x[0] <= end_revision))]
138
 
 
139
 
    if not (verbose or specific_fileid):
140
 
        # no need to know what changed between revisions
141
 
        with_deltas = deltas_for_log_dummy(branch, which_revs)
142
 
    elif direction == 'reverse':
143
 
        with_deltas = deltas_for_log_reverse(branch, which_revs)
144
 
    else:        
145
 
        with_deltas = deltas_for_log_forward(branch, which_revs)
146
 
 
147
 
    for revno, rev, delta in with_deltas:
 
187
    which_revs = _enumerate_history(branch)
 
188
    
 
189
    if start_revision is None:
 
190
        start_revision = 1
 
191
    else:
 
192
        branch.check_real_revno(start_revision)
 
193
    
 
194
    if end_revision is None:
 
195
        end_revision = len(which_revs)
 
196
    else:
 
197
        branch.check_real_revno(end_revision)
 
198
 
 
199
    # list indexes are 0-based; revisions are 1-based
 
200
    cut_revs = which_revs[(start_revision-1):(end_revision)]
 
201
 
 
202
    if direction == 'reverse':
 
203
        cut_revs.reverse()
 
204
    elif direction == 'forward':
 
205
        pass
 
206
    else:
 
207
        raise ValueError('invalid direction %r' % direction)
 
208
 
 
209
    for revno, rev_id in cut_revs:
 
210
        if verbose or specific_fileid:
 
211
            delta = _get_revision_delta(branch, revno)
 
212
            
148
213
        if specific_fileid:
149
214
            if not delta.touches_file_id(specific_fileid):
150
215
                continue
153
218
            # although we calculated it, throw it away without display
154
219
            delta = None
155
220
 
156
 
        if searchRE is None or searchRE.search(rev.message):
157
 
            lf.show(revno, rev, delta)
 
221
        rev = branch.get_revision(rev_id)
 
222
 
 
223
        if searchRE:
 
224
            if not searchRE.search(rev.message):
 
225
                continue
 
226
 
 
227
        lf.show(revno, rev, delta)
158
228
 
159
229
 
160
230
 
161
231
def deltas_for_log_dummy(branch, which_revs):
 
232
    """Return all the revisions without intermediate deltas.
 
233
 
 
234
    Useful for log commands that won't need the delta information.
 
235
    """
 
236
    
162
237
    for revno, revision_id in which_revs:
163
238
        yield revno, branch.get_revision(revision_id), None
164
239
 
165
240
 
166
241
def deltas_for_log_reverse(branch, which_revs):
167
 
    """Compute deltas for display in reverse log.
168
 
 
169
 
    Given a sequence of (revno, revision_id) pairs, return
170
 
    (revno, rev, delta).
 
242
    """Compute deltas for display in latest-to-earliest order.
 
243
 
 
244
    branch
 
245
        Branch to traverse
 
246
 
 
247
    which_revs
 
248
        Sequence of (revno, revision_id) for the subset of history to examine
 
249
 
 
250
    returns 
 
251
        Sequence of (revno, rev, delta)
171
252
 
172
253
    The delta is from the given revision to the next one in the
173
254
    sequence, which makes sense if the log is being displayed from
174
255
    newest to oldest.
175
256
    """
176
 
    from tree import EmptyTree
177
 
    from diff import compare_trees
178
 
    
179
257
    last_revno = last_revision_id = last_tree = None
180
258
    for revno, revision_id in which_revs:
181
259
        this_tree = branch.revision_tree(revision_id)
210
288
    sequence, which makes sense if the log is being displayed from
211
289
    newest to oldest.
212
290
    """
213
 
    from tree import EmptyTree
214
 
    from diff import compare_trees
215
 
 
216
291
    last_revno = last_revision_id = last_tree = None
217
292
    prev_tree = EmptyTree(branch.get_root_id())
218
293
 
237
312
 
238
313
class LogFormatter(object):
239
314
    """Abstract class to display log messages."""
240
 
    def __init__(self, to_file, show_ids=False, show_timezone=False):
 
315
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
241
316
        self.to_file = to_file
242
317
        self.show_ids = show_ids
243
318
        self.show_timezone = show_timezone
244
 
        
245
 
 
246
 
 
247
 
 
248
 
 
249
 
 
 
319
 
 
320
 
 
321
    def show(self, revno, rev, delta):
 
322
        raise NotImplementedError('not implemented in abstract base')
 
323
 
 
324
    
250
325
class LongLogFormatter(LogFormatter):
251
326
    def show(self, revno, rev, delta):
252
327
        from osutils import format_date
257
332
        print >>to_file,  'revno:', revno
258
333
        if self.show_ids:
259
334
            print >>to_file,  'revision-id:', rev.revision_id
 
335
 
 
336
            for parent_id in rev.parent_ids:
 
337
                print >>to_file, 'parent:', parent_id
 
338
            
260
339
        print >>to_file,  'committer:', rev.committer
261
 
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
262
 
                                             self.show_timezone))
 
340
 
 
341
        date_str = format_date(rev.timestamp,
 
342
                               rev.timezone or 0,
 
343
                               self.show_timezone)
 
344
        print >>to_file,  'timestamp: %s' % date_str
263
345
 
264
346
        print >>to_file,  'message:'
265
347
        if not rev.message:
290
372
            for l in rev.message.split('\n'):
291
373
                print >>to_file,  '      ' + l
292
374
 
 
375
        # TODO: Why not show the modified files in a shorter form as
 
376
        # well? rewrap them single lines of appropriate length
293
377
        if delta != None:
294
378
            delta.show(to_file, self.show_ids)
295
379
        print
302
386
 
303
387
 
304
388
def log_formatter(name, *args, **kwargs):
 
389
    """Construct a formatter from arguments.
 
390
 
 
391
    name -- Name of the formatter to construct; currently 'long' and
 
392
        'short' are supported.
 
393
    """
305
394
    from bzrlib.errors import BzrCommandError
306
 
    
307
395
    try:
308
396
        return FORMATTERS[name](*args, **kwargs)
309
397
    except IndexError:
310
398
        raise BzrCommandError("unknown log formatter: %r" % name)
 
399
 
 
400
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
401
    # deprecated; for compatability
 
402
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
403
    lf.show(revno, rev, delta)