/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

More work on roundtrip push support.

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)