← 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-05-06 03:20:15 UTC
  • Revision ID: mbp@sourcefrog.net-20050506032014-decf4918803147d2
- split out notes on storing annotations in revfiles

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