/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Robert Collins
  • Date: 2005-10-10 00:05:25 UTC
  • Revision ID: robertc@robertcollins.net-20051010000525-cbfcc0ff413510c5
BUGFIX: disable symlink support tests when no symlink support is present on the system.

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 _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
 
 
123
def show_log(branch,
 
124
             lf,
 
125
             specific_fileid=None,
 
126
             verbose=False,
 
127
             direction='reverse',
 
128
             start_revision=None,
 
129
             end_revision=None,
 
130
             search=None):
 
131
    """Write out human-readable log of commits to this branch.
 
132
 
 
133
    lf
 
134
        LogFormatter object to show the output.
 
135
 
 
136
    specific_fileid
 
137
        If true, list only the commits affecting the specified
 
138
        file, rather than all commits.
 
139
 
 
140
    verbose
 
141
        If true show added/changed/deleted/renamed files.
 
142
 
 
143
    direction
 
144
        'reverse' (default) is latest to earliest;
 
145
        'forward' is earliest to latest.
 
146
 
 
147
    start_revision
 
148
        If not None, only show revisions >= start_revision
 
149
 
 
150
    end_revision
 
151
        If not None, only show revisions <= end_revision
 
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."""
 
169
    from bzrlib.osutils import format_date
 
170
    from bzrlib.errors import BzrCheckError
 
171
    from bzrlib.textui import show_status
 
172
    
 
173
    from warnings import warn
 
174
 
 
175
    if not isinstance(lf, LogFormatter):
 
176
        warn("not a LogFormatter instance: %r" % lf)
 
177
 
 
178
    if specific_fileid:
 
179
        mutter('get log for file_id %r' % specific_fileid)
 
180
 
 
181
    if search is not None:
 
182
        import re
 
183
        searchRE = re.compile(search, re.IGNORECASE)
 
184
    else:
 
185
        searchRE = None
 
186
 
 
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
            
 
213
        if specific_fileid:
 
214
            if not delta.touches_file_id(specific_fileid):
 
215
                continue
 
216
 
 
217
        if not verbose:
 
218
            # although we calculated it, throw it away without display
 
219
            delta = None
 
220
 
 
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)
 
228
 
 
229
 
 
230
 
 
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
    
 
237
    for revno, revision_id in which_revs:
 
238
        yield revno, branch.get_revision(revision_id), None
 
239
 
 
240
 
 
241
def deltas_for_log_reverse(branch, which_revs):
 
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)
 
252
 
 
253
    The delta is from the given revision to the next one in the
 
254
    sequence, which makes sense if the log is being displayed from
 
255
    newest to oldest.
 
256
    """
 
257
    last_revno = last_revision_id = last_tree = None
 
258
    for revno, revision_id in which_revs:
 
259
        this_tree = branch.revision_tree(revision_id)
 
260
        this_revision = branch.get_revision(revision_id)
 
261
        
 
262
        if last_revno:
 
263
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
264
 
 
265
        this_tree = EmptyTree(branch.get_root_id())
 
266
 
 
267
        last_revno = revno
 
268
        last_revision = this_revision
 
269
        last_tree = this_tree
 
270
 
 
271
    if last_revno:
 
272
        if last_revno == 1:
 
273
            this_tree = EmptyTree(branch.get_root_id())
 
274
        else:
 
275
            this_revno = last_revno - 1
 
276
            this_revision_id = branch.revision_history()[this_revno]
 
277
            this_tree = branch.revision_tree(this_revision_id)
 
278
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
279
 
 
280
 
 
281
def deltas_for_log_forward(branch, which_revs):
 
282
    """Compute deltas for display in forward log.
 
283
 
 
284
    Given a sequence of (revno, revision_id) pairs, return
 
285
    (revno, rev, delta).
 
286
 
 
287
    The delta is from the given revision to the next one in the
 
288
    sequence, which makes sense if the log is being displayed from
 
289
    newest to oldest.
 
290
    """
 
291
    last_revno = last_revision_id = last_tree = None
 
292
    prev_tree = EmptyTree(branch.get_root_id())
 
293
 
 
294
    for revno, revision_id in which_revs:
 
295
        this_tree = branch.revision_tree(revision_id)
 
296
        this_revision = branch.get_revision(revision_id)
 
297
 
 
298
        if not last_revno:
 
299
            if revno == 1:
 
300
                last_tree = EmptyTree(branch.get_root_id())
 
301
            else:
 
302
                last_revno = revno - 1
 
303
                last_revision_id = branch.revision_history()[last_revno]
 
304
                last_tree = branch.revision_tree(last_revision_id)
 
305
 
 
306
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
307
 
 
308
        last_revno = revno
 
309
        last_revision = this_revision
 
310
        last_tree = this_tree
 
311
 
 
312
 
 
313
class LogFormatter(object):
 
314
    """Abstract class to display log messages."""
 
315
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
316
        self.to_file = to_file
 
317
        self.show_ids = show_ids
 
318
        self.show_timezone = show_timezone
 
319
 
 
320
 
 
321
    def show(self, revno, rev, delta):
 
322
        raise NotImplementedError('not implemented in abstract base')
 
323
 
 
324
    
 
325
class LongLogFormatter(LogFormatter):
 
326
    def show(self, revno, rev, delta):
 
327
        from osutils import format_date
 
328
 
 
329
        to_file = self.to_file
 
330
 
 
331
        print >>to_file,  '-' * 60
 
332
        print >>to_file,  'revno:', revno
 
333
        if self.show_ids:
 
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
            
 
339
        print >>to_file,  'committer:', rev.committer
 
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
 
345
 
 
346
        print >>to_file,  'message:'
 
347
        if not rev.message:
 
348
            print >>to_file,  '  (no message)'
 
349
        else:
 
350
            for l in rev.message.split('\n'):
 
351
                print >>to_file,  '  ' + l
 
352
 
 
353
        if delta != None:
 
354
            delta.show(to_file, self.show_ids)
 
355
 
 
356
 
 
357
 
 
358
class ShortLogFormatter(LogFormatter):
 
359
    def show(self, revno, rev, delta):
 
360
        from bzrlib.osutils import format_date
 
361
 
 
362
        to_file = self.to_file
 
363
 
 
364
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
 
365
                format_date(rev.timestamp, rev.timezone or 0,
 
366
                            self.show_timezone))
 
367
        if self.show_ids:
 
368
            print >>to_file,  '      revision-id:', rev.revision_id
 
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
        # TODO: Why not show the modified files in a shorter form as
 
376
        # well? rewrap them single lines of appropriate length
 
377
        if delta != None:
 
378
            delta.show(to_file, self.show_ids)
 
379
        print
 
380
 
 
381
 
 
382
 
 
383
FORMATTERS = {'long': LongLogFormatter,
 
384
              'short': ShortLogFormatter,
 
385
              }
 
386
 
 
387
 
 
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
    """
 
394
    from bzrlib.errors import BzrCommandError
 
395
    try:
 
396
        return FORMATTERS[name](*args, **kwargs)
 
397
    except IndexError:
 
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)