/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: Martin Pool
  • Date: 2005-07-29 22:47:55 UTC
  • Revision ID: mbp@sourcefrog.net-20050729224755-00dd53f95d62b05b
- add Branch.get_revision_delta

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 show_log(branch,
 
104
             lf,
 
105
             specific_fileid=None,
 
106
             verbose=False,
 
107
             direction='reverse',
 
108
             start_revision=None,
 
109
             end_revision=None,
 
110
             search=None):
 
111
    """Write out human-readable log of commits to this branch.
 
112
 
 
113
    lf
 
114
        LogFormatter object to show the output.
 
115
 
 
116
    specific_fileid
 
117
        If true, list only the commits affecting the specified
 
118
        file, rather than all commits.
 
119
 
 
120
    verbose
 
121
        If true show added/changed/deleted/renamed files.
 
122
 
 
123
    direction
 
124
        'reverse' (default) is latest to earliest;
 
125
        'forward' is earliest to latest.
 
126
 
 
127
    start_revision
 
128
        If not None, only show revisions >= start_revision
 
129
 
 
130
    end_revision
 
131
        If not None, only show revisions <= end_revision
 
132
    """
 
133
    from bzrlib.osutils import format_date
 
134
    from bzrlib.errors import BzrCheckError
 
135
    from bzrlib.textui import show_status
 
136
    
 
137
    from warnings import warn
 
138
 
 
139
    if not isinstance(lf, LogFormatter):
 
140
        warn("not a LogFormatter instance: %r" % lf)
 
141
 
 
142
    if specific_fileid:
 
143
        mutter('get log for file_id %r' % specific_fileid)
 
144
 
 
145
    if search is not None:
 
146
        import re
 
147
        searchRE = re.compile(search, re.IGNORECASE)
 
148
    else:
 
149
        searchRE = None
 
150
 
 
151
    which_revs = branch.enum_history(direction)
 
152
    which_revs = [x for x in which_revs if (
 
153
            (start_revision is None or x[0] >= start_revision)
 
154
            and (end_revision is None or x[0] <= end_revision))]
 
155
 
 
156
    if not (verbose or specific_fileid):
 
157
        # no need to know what changed between revisions
 
158
        with_deltas = deltas_for_log_dummy(branch, which_revs)
 
159
    elif direction == 'reverse':
 
160
        with_deltas = deltas_for_log_reverse(branch, which_revs)
 
161
    else:        
 
162
        with_deltas = deltas_for_log_forward(branch, which_revs)
 
163
 
 
164
    for revno, rev, delta in with_deltas:
 
165
        if specific_fileid:
 
166
            if not delta.touches_file_id(specific_fileid):
 
167
                continue
 
168
 
 
169
        if not verbose:
 
170
            # although we calculated it, throw it away without display
 
171
            delta = None
 
172
 
 
173
        if searchRE is None or searchRE.search(rev.message):
 
174
            lf.show(revno, rev, delta)
 
175
 
 
176
 
 
177
 
 
178
def deltas_for_log_dummy(branch, which_revs):
 
179
    """Return all the revisions without intermediate deltas.
 
180
 
 
181
    Useful for log commands that won't need the delta information.
 
182
    """
 
183
    
 
184
    for revno, revision_id in which_revs:
 
185
        yield revno, branch.get_revision(revision_id), None
 
186
 
 
187
 
 
188
def deltas_for_log_reverse(branch, which_revs):
 
189
    """Compute deltas for display in latest-to-earliest order.
 
190
 
 
191
    branch
 
192
        Branch to traverse
 
193
 
 
194
    which_revs
 
195
        Sequence of (revno, revision_id) for the subset of history to examine
 
196
 
 
197
    returns 
 
198
        Sequence of (revno, rev, delta)
 
199
 
 
200
    The delta is from the given revision to the next one in the
 
201
    sequence, which makes sense if the log is being displayed from
 
202
    newest to oldest.
 
203
    """
 
204
    last_revno = last_revision_id = last_tree = None
 
205
    for revno, revision_id in which_revs:
 
206
        this_tree = branch.revision_tree(revision_id)
 
207
        this_revision = branch.get_revision(revision_id)
 
208
        
 
209
        if last_revno:
 
210
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
211
 
 
212
        this_tree = EmptyTree(branch.get_root_id())
 
213
 
 
214
        last_revno = revno
 
215
        last_revision = this_revision
 
216
        last_tree = this_tree
 
217
 
 
218
    if last_revno:
 
219
        if last_revno == 1:
 
220
            this_tree = EmptyTree(branch.get_root_id())
 
221
        else:
 
222
            this_revno = last_revno - 1
 
223
            this_revision_id = branch.revision_history()[this_revno]
 
224
            this_tree = branch.revision_tree(this_revision_id)
 
225
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
226
 
 
227
 
 
228
def deltas_for_log_forward(branch, which_revs):
 
229
    """Compute deltas for display in forward log.
 
230
 
 
231
    Given a sequence of (revno, revision_id) pairs, return
 
232
    (revno, rev, delta).
 
233
 
 
234
    The delta is from the given revision to the next one in the
 
235
    sequence, which makes sense if the log is being displayed from
 
236
    newest to oldest.
 
237
    """
 
238
    last_revno = last_revision_id = last_tree = None
 
239
    prev_tree = EmptyTree(branch.get_root_id())
 
240
 
 
241
    for revno, revision_id in which_revs:
 
242
        this_tree = branch.revision_tree(revision_id)
 
243
        this_revision = branch.get_revision(revision_id)
 
244
 
 
245
        if not last_revno:
 
246
            if revno == 1:
 
247
                last_tree = EmptyTree(branch.get_root_id())
 
248
            else:
 
249
                last_revno = revno - 1
 
250
                last_revision_id = branch.revision_history()[last_revno]
 
251
                last_tree = branch.revision_tree(last_revision_id)
 
252
 
 
253
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
254
 
 
255
        last_revno = revno
 
256
        last_revision = this_revision
 
257
        last_tree = this_tree
 
258
 
 
259
 
 
260
class LogFormatter(object):
 
261
    """Abstract class to display log messages."""
 
262
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
263
        self.to_file = to_file
 
264
        self.show_ids = show_ids
 
265
        self.show_timezone = show_timezone
 
266
 
 
267
 
 
268
    def show(self, revno, rev, delta):
 
269
        raise NotImplementedError('not implemented in abstract base')
 
270
        
 
271
 
 
272
 
 
273
 
 
274
 
 
275
 
 
276
class LongLogFormatter(LogFormatter):
 
277
    def show(self, revno, rev, delta):
 
278
        from osutils import format_date
 
279
 
 
280
        to_file = self.to_file
 
281
 
 
282
        print >>to_file,  '-' * 60
 
283
        print >>to_file,  'revno:', revno
 
284
        if self.show_ids:
 
285
            print >>to_file,  'revision-id:', rev.revision_id
 
286
        print >>to_file,  'committer:', rev.committer
 
287
 
 
288
        date_str = format_date(rev.timestamp,
 
289
                               rev.timezone or 0,
 
290
                               self.show_timezone)
 
291
        print >>to_file,  'timestamp: %s' % date_str
 
292
 
 
293
        print >>to_file,  'message:'
 
294
        if not rev.message:
 
295
            print >>to_file,  '  (no message)'
 
296
        else:
 
297
            for l in rev.message.split('\n'):
 
298
                print >>to_file,  '  ' + l
 
299
 
 
300
        if delta != None:
 
301
            delta.show(to_file, self.show_ids)
 
302
 
 
303
 
 
304
 
 
305
class ShortLogFormatter(LogFormatter):
 
306
    def show(self, revno, rev, delta):
 
307
        from bzrlib.osutils import format_date
 
308
 
 
309
        to_file = self.to_file
 
310
 
 
311
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
 
312
                format_date(rev.timestamp, rev.timezone or 0,
 
313
                            self.show_timezone))
 
314
        if self.show_ids:
 
315
            print >>to_file,  '      revision-id:', rev.revision_id
 
316
        if not rev.message:
 
317
            print >>to_file,  '      (no message)'
 
318
        else:
 
319
            for l in rev.message.split('\n'):
 
320
                print >>to_file,  '      ' + l
 
321
 
 
322
        # TODO: Why not show the modified files in a shorter form as
 
323
        # well? rewrap them single lines of appropriate length
 
324
        if delta != None:
 
325
            delta.show(to_file, self.show_ids)
 
326
        print
 
327
 
 
328
 
 
329
 
 
330
FORMATTERS = {'long': LongLogFormatter,
 
331
              'short': ShortLogFormatter,
 
332
              }
 
333
 
 
334
 
 
335
def log_formatter(name, *args, **kwargs):
 
336
    from bzrlib.errors import BzrCommandError
 
337
    
 
338
    try:
 
339
        return FORMATTERS[name](*args, **kwargs)
 
340
    except IndexError:
 
341
        raise BzrCommandError("unknown log formatter: %r" % name)
 
342
 
 
343
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
344
    # deprecated; for compatability
 
345
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
346
    lf.show(revno, rev, delta)