← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Martin Pool
  • Date: 2005-07-23 13:52:38 UTC
  • Revision ID: mbp@sourcefrog.net-20050723135238-96b1580de8dff136
doc

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
16
16
 
17
17
 
18
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
* 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
 
36
"""
 
37
 
 
38
 
 
39
from trace import mutter
19
40
 
20
41
def find_touching_revisions(branch, file_id):
21
42
    """Yield a description of revisions which affect the file_id.
25
46
    This is the list of revisions where the file is either added,
26
47
    modified, renamed or deleted.
27
48
 
28
 
    Revisions are returned in chronological order.
29
 
 
30
49
    TODO: Perhaps some way to limit this to only particular revisions,
31
 
    or to traverse a non-branch set of revisions?
32
 
 
33
 
    TODO: If a directory is given, then by default look for all
34
 
    changes under that directory.
 
50
    or to traverse a non-mainline set of revisions?
35
51
    """
36
52
    last_ie = None
37
53
    last_path = None
66
82
        revno += 1
67
83
 
68
84
 
 
85
 
69
86
def show_log(branch,
70
 
             filename=None,
71
 
             show_timezone='original',
 
87
             lf,
 
88
             specific_fileid=None,
72
89
             verbose=False,
73
 
             show_ids=False,
74
 
             to_file=None):
 
90
             direction='reverse',
 
91
             start_revision=None,
 
92
             end_revision=None,
 
93
             search=None):
75
94
    """Write out human-readable log of commits to this branch.
76
95
 
77
 
    filename
 
96
    lf
 
97
        LogFormatter object to show the output.
 
98
 
 
99
    specific_fileid
78
100
        If true, list only the commits affecting the specified
79
101
        file, rather than all commits.
80
102
 
81
 
    show_timezone
82
 
        'original' (committer's timezone),
83
 
        'utc' (universal time), or
84
 
        'local' (local user's timezone)
85
 
 
86
103
    verbose
87
104
        If true show added/changed/deleted/renamed files.
88
105
 
89
 
    show_ids
90
 
        If true, show revision and file ids.
91
 
 
92
 
    to_file
93
 
        File to send log to; by default stdout.
 
106
    direction
 
107
        'reverse' (default) is latest to earliest;
 
108
        'forward' is earliest to latest.
 
109
 
 
110
    start_revision
 
111
        If not None, only show revisions >= start_revision
 
112
 
 
113
    end_revision
 
114
        If not None, only show revisions <= end_revision
94
115
    """
95
 
    from osutils import format_date
96
 
    from errors import BzrCheckError
97
 
    from diff import compare_trees
98
 
    from textui import show_status
99
 
 
100
 
    if to_file == None:
101
 
        import sys
102
 
        to_file = sys.stdout
103
 
 
104
 
    if filename:
105
 
        file_id = branch.read_working_inventory().path2id(filename)
106
 
        def which_revs():
107
 
            for revno, revid, why in find_touching_revisions(branch, file_id):
108
 
                yield revno, revid
 
116
    from bzrlib.osutils import format_date
 
117
    from bzrlib.errors import BzrCheckError
 
118
    from bzrlib.textui import show_status
 
119
    
 
120
    from warnings import warn
 
121
 
 
122
    if not isinstance(lf, LogFormatter):
 
123
        warn("not a LogFormatter instance: %r" % lf)
 
124
 
 
125
    if specific_fileid:
 
126
        mutter('get log for file_id %r' % specific_fileid)
 
127
 
 
128
    if search is not None:
 
129
        import re
 
130
        searchRE = re.compile(search, re.IGNORECASE)
109
131
    else:
110
 
        def which_revs():
111
 
            for i, revid in enumerate(branch.revision_history()):
112
 
                yield i+1, revid
113
 
        
114
 
    branch._need_readlock()
115
 
    precursor = None
116
 
    if verbose:
117
 
        from tree import EmptyTree
118
 
        prev_tree = EmptyTree()
119
 
    for revno, revision_id in which_revs():
 
132
        searchRE = None
 
133
 
 
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:
 
148
        if specific_fileid:
 
149
            if not delta.touches_file_id(specific_fileid):
 
150
                continue
 
151
 
 
152
        if not verbose:
 
153
            # although we calculated it, throw it away without display
 
154
            delta = None
 
155
 
 
156
        if searchRE is None or searchRE.search(rev.message):
 
157
            lf.show(revno, rev, delta)
 
158
 
 
159
 
 
160
 
 
161
def deltas_for_log_dummy(branch, which_revs):
 
162
    for revno, revision_id in which_revs:
 
163
        yield revno, branch.get_revision(revision_id), None
 
164
 
 
165
 
 
166
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).
 
171
 
 
172
    The delta is from the given revision to the next one in the
 
173
    sequence, which makes sense if the log is being displayed from
 
174
    newest to oldest.
 
175
    """
 
176
    from tree import EmptyTree
 
177
    from diff import compare_trees
 
178
    
 
179
    last_revno = last_revision_id = last_tree = None
 
180
    for revno, revision_id in which_revs:
 
181
        this_tree = branch.revision_tree(revision_id)
 
182
        this_revision = branch.get_revision(revision_id)
 
183
        
 
184
        if last_revno:
 
185
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
186
 
 
187
        this_tree = EmptyTree(branch.get_root_id())
 
188
 
 
189
        last_revno = revno
 
190
        last_revision = this_revision
 
191
        last_tree = this_tree
 
192
 
 
193
    if last_revno:
 
194
        if last_revno == 1:
 
195
            this_tree = EmptyTree(branch.get_root_id())
 
196
        else:
 
197
            this_revno = last_revno - 1
 
198
            this_revision_id = branch.revision_history()[this_revno]
 
199
            this_tree = branch.revision_tree(this_revision_id)
 
200
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
201
 
 
202
 
 
203
def deltas_for_log_forward(branch, which_revs):
 
204
    """Compute deltas for display in forward log.
 
205
 
 
206
    Given a sequence of (revno, revision_id) pairs, return
 
207
    (revno, rev, delta).
 
208
 
 
209
    The delta is from the given revision to the next one in the
 
210
    sequence, which makes sense if the log is being displayed from
 
211
    newest to oldest.
 
212
    """
 
213
    from tree import EmptyTree
 
214
    from diff import compare_trees
 
215
 
 
216
    last_revno = last_revision_id = last_tree = None
 
217
    prev_tree = EmptyTree(branch.get_root_id())
 
218
 
 
219
    for revno, revision_id in which_revs:
 
220
        this_tree = branch.revision_tree(revision_id)
 
221
        this_revision = branch.get_revision(revision_id)
 
222
 
 
223
        if not last_revno:
 
224
            if revno == 1:
 
225
                last_tree = EmptyTree(branch.get_root_id())
 
226
            else:
 
227
                last_revno = revno - 1
 
228
                last_revision_id = branch.revision_history()[last_revno]
 
229
                last_tree = branch.revision_tree(last_revision_id)
 
230
 
 
231
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
232
 
 
233
        last_revno = revno
 
234
        last_revision = this_revision
 
235
        last_tree = this_tree
 
236
 
 
237
 
 
238
class LogFormatter(object):
 
239
    """Abstract class to display log messages."""
 
240
    def __init__(self, to_file, show_ids=False, show_timezone=False):
 
241
        self.to_file = to_file
 
242
        self.show_ids = show_ids
 
243
        self.show_timezone = show_timezone
 
244
        
 
245
 
 
246
 
 
247
 
 
248
 
 
249
 
 
250
class LongLogFormatter(LogFormatter):
 
251
    def show(self, revno, rev, delta):
 
252
        from osutils import format_date
 
253
 
 
254
        to_file = self.to_file
 
255
 
120
256
        print >>to_file,  '-' * 60
121
257
        print >>to_file,  'revno:', revno
122
 
        rev = branch.get_revision(revision_id)
123
 
        if show_ids:
124
 
            print >>to_file,  'revision-id:', revision_id
 
258
        if self.show_ids:
 
259
            print >>to_file,  'revision-id:', rev.revision_id
125
260
        print >>to_file,  'committer:', rev.committer
126
261
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
127
 
                                             show_timezone))
128
 
 
129
 
        if revision_id != rev.revision_id:
130
 
            raise BzrCheckError("retrieved wrong revision: %r"
131
 
                                % (revision_id, rev.revision_id))
 
262
                                             self.show_timezone))
132
263
 
133
264
        print >>to_file,  'message:'
134
265
        if not rev.message:
137
268
            for l in rev.message.split('\n'):
138
269
                print >>to_file,  '  ' + l
139
270
 
140
 
        # Don't show a list of changed files if we were asked about
141
 
        # one specific file.
142
 
 
143
 
        if verbose:
144
 
            this_tree = branch.revision_tree(revision_id)
145
 
            delta = compare_trees(prev_tree, this_tree, want_unchanged=False)
146
 
            delta.show(to_file, show_ids)
147
 
            prev_tree = this_tree
148
 
 
149
 
        precursor = revision_id
150
 
 
 
271
        if delta != None:
 
272
            delta.show(to_file, self.show_ids)
 
273
 
 
274
 
 
275
 
 
276
class ShortLogFormatter(LogFormatter):
 
277
    def show(self, revno, rev, delta):
 
278
        from bzrlib.osutils import format_date
 
279
 
 
280
        to_file = self.to_file
 
281
 
 
282
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
 
283
                format_date(rev.timestamp, rev.timezone or 0,
 
284
                            self.show_timezone))
 
285
        if self.show_ids:
 
286
            print >>to_file,  '      revision-id:', rev.revision_id
 
287
        if not rev.message:
 
288
            print >>to_file,  '      (no message)'
 
289
        else:
 
290
            for l in rev.message.split('\n'):
 
291
                print >>to_file,  '      ' + l
 
292
 
 
293
        if delta != None:
 
294
            delta.show(to_file, self.show_ids)
 
295
        print
 
296
 
 
297
 
 
298
 
 
299
FORMATTERS = {'long': LongLogFormatter,
 
300
              'short': ShortLogFormatter,
 
301
              }
 
302
 
 
303
 
 
304
def log_formatter(name, *args, **kwargs):
 
305
    from bzrlib.errors import BzrCommandError
 
306
    
 
307
    try:
 
308
        return FORMATTERS[name](*args, **kwargs)
 
309
    except IndexError:
 
310
        raise BzrCommandError("unknown log formatter: %r" % name)