← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

Fix BzrDir.create_workingtree for NULL_REVISION

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
1
1
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
49
49
all the changes since the previous revision that touched hello.c.
50
50
"""
51
51
 
52
 
 
53
52
# TODO: option to show delta summaries for merged-in revisions
54
53
 
 
54
from itertools import izip
 
55
import re
 
56
 
55
57
import bzrlib.errors as errors
56
 
from bzrlib.tree import EmptyTree
57
 
from bzrlib.delta import compare_trees
58
58
from bzrlib.trace import mutter
59
 
import re
 
59
from bzrlib.tsort import merge_sort
60
60
 
61
61
 
62
62
def find_touching_revisions(branch, file_id):
74
74
    last_path = None
75
75
    revno = 1
76
76
    for revision_id in branch.revision_history():
77
 
        this_inv = branch.get_revision_inventory(revision_id)
 
77
        this_inv = branch.repository.get_revision_inventory(revision_id)
78
78
        if file_id in this_inv:
79
79
            this_ie = this_inv[file_id]
80
80
            this_path = this_inv.id2path(file_id)
113
113
    return rh
114
114
 
115
115
 
116
 
def _get_revision_delta(branch, revno):
117
 
    """Return the delta for a mainline revision.
118
 
    
119
 
    This is used to show summaries in verbose logs, and also for finding 
120
 
    revisions which touch a given file."""
121
 
    # XXX: What are we supposed to do when showing a summary for something 
122
 
    # other than a mainline revision.  The delta to it's first parent, or
123
 
    # (more useful) the delta to a nominated other revision.
124
 
    return branch.get_revision_delta(revno)
125
 
 
126
 
 
127
116
def show_log(branch,
128
117
             lf,
129
118
             specific_fileid=None,
172
161
    """Worker function for show_log - see show_log."""
173
162
    from bzrlib.osutils import format_date
174
163
    from bzrlib.errors import BzrCheckError
175
 
    from bzrlib.textui import show_status
176
164
    
177
165
    from warnings import warn
178
166
 
202
190
 
203
191
    # list indexes are 0-based; revisions are 1-based
204
192
    cut_revs = which_revs[(start_revision-1):(end_revision)]
205
 
 
206
 
    if direction == 'reverse':
207
 
        cut_revs.reverse()
208
 
    elif direction == 'forward':
209
 
        pass
210
 
    else:
211
 
        raise ValueError('invalid direction %r' % direction)
212
 
 
213
 
    revision_history = branch.revision_history()
214
 
    for revno, rev_id in cut_revs:
215
 
        if verbose or specific_fileid:
216
 
            delta = _get_revision_delta(branch, revno)
 
193
    if not cut_revs:
 
194
        return
 
195
 
 
196
    # convert the revision history to a dictionary:
 
197
    rev_nos = dict((k, v) for v, k in cut_revs)
 
198
 
 
199
    # override the mainline to look like the revision history.
 
200
    mainline_revs = [revision_id for index, revision_id in cut_revs]
 
201
    if cut_revs[0][0] == 1:
 
202
        mainline_revs.insert(0, None)
 
203
    else:
 
204
        mainline_revs.insert(0, which_revs[start_revision-2][1])
 
205
    if getattr(lf, 'show_merge', None) is not None:
 
206
        include_merges = True 
 
207
    else:
 
208
        include_merges = False 
 
209
    view_revisions = list(get_view_revisions(mainline_revs, rev_nos, branch,
 
210
                          direction, include_merges=include_merges))
 
211
 
 
212
    def iter_revisions():
 
213
        # r = revision, n = revno, d = merge depth
 
214
        revision_ids = [r for r, n, d in view_revisions]
 
215
        zeros = set(r for r, n, d in view_revisions if d == 0)
 
216
        num = 9
 
217
        repository = branch.repository
 
218
        while revision_ids:
 
219
            cur_deltas = {}
 
220
            revisions = repository.get_revisions(revision_ids[:num])
 
221
            if verbose or specific_fileid:
 
222
                delta_revisions = [r for r in revisions if
 
223
                                   r.revision_id in zeros]
 
224
                deltas = repository.get_deltas_for_revisions(delta_revisions)
 
225
                cur_deltas = dict(izip((r.revision_id for r in 
 
226
                                        delta_revisions), deltas))
 
227
            for revision in revisions:
 
228
                # The delta value will be None unless
 
229
                # 1. verbose or specific_fileid is specified, and
 
230
                # 2. the revision is a mainline revision
 
231
                yield revision, cur_deltas.get(revision.revision_id)
 
232
            revision_ids  = revision_ids[num:]
 
233
            num = int(num * 1.5)
217
234
            
218
 
        if specific_fileid:
219
 
            if not delta.touches_file_id(specific_fileid):
220
 
                continue
221
 
 
222
 
        if not verbose:
223
 
            # although we calculated it, throw it away without display
224
 
            delta = None
225
 
 
226
 
        rev = branch.get_revision(rev_id)
 
235
    # now we just print all the revisions
 
236
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
 
237
         izip(view_revisions, iter_revisions()):
227
238
 
228
239
        if searchRE:
229
240
            if not searchRE.search(rev.message):
230
241
                continue
231
242
 
232
 
        lf.show(revno, rev, delta)
233
 
        if hasattr(lf, 'show_merge'):
234
 
            if revno == 1:
235
 
                excludes = set()
236
 
            else:
237
 
                # revno is 1 based, so -2 to get back 1 less.
238
 
                excludes = set(branch.get_ancestry(revision_history[revno - 2]))
239
 
            pending = list(rev.parent_ids)
240
 
            while pending:
241
 
                rev_id = pending.pop()
242
 
                if rev_id in excludes:
243
 
                    continue
244
 
                # prevent showing merged revs twice if they multi-path.
245
 
                excludes.add(rev_id)
246
 
                try:
247
 
                    rev = branch.get_revision(rev_id)
248
 
                except errors.NoSuchRevision:
249
 
                    continue
250
 
                pending.extend(rev.parent_ids)
251
 
                lf.show_merge(rev)
252
 
 
253
 
 
254
 
def deltas_for_log_dummy(branch, which_revs):
255
 
    """Return all the revisions without intermediate deltas.
256
 
 
257
 
    Useful for log commands that won't need the delta information.
258
 
    """
 
243
        if merge_depth == 0:
 
244
            # a mainline revision.
 
245
                
 
246
            if specific_fileid:
 
247
                if not delta.touches_file_id(specific_fileid):
 
248
                    continue
259
249
    
260
 
    for revno, revision_id in which_revs:
261
 
        yield revno, branch.get_revision(revision_id), None
262
 
 
263
 
 
264
 
def deltas_for_log_reverse(branch, which_revs):
265
 
    """Compute deltas for display in latest-to-earliest order.
266
 
 
267
 
    branch
268
 
        Branch to traverse
269
 
 
270
 
    which_revs
271
 
        Sequence of (revno, revision_id) for the subset of history to examine
272
 
 
273
 
    returns 
274
 
        Sequence of (revno, rev, delta)
275
 
 
276
 
    The delta is from the given revision to the next one in the
277
 
    sequence, which makes sense if the log is being displayed from
278
 
    newest to oldest.
279
 
    """
280
 
    last_revno = last_revision_id = last_tree = None
281
 
    for revno, revision_id in which_revs:
282
 
        this_tree = branch.revision_tree(revision_id)
283
 
        this_revision = branch.get_revision(revision_id)
284
 
        
285
 
        if last_revno:
286
 
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
287
 
 
288
 
        this_tree = EmptyTree(branch.get_root_id())
289
 
 
290
 
        last_revno = revno
291
 
        last_revision = this_revision
292
 
        last_tree = this_tree
293
 
 
294
 
    if last_revno:
295
 
        if last_revno == 1:
296
 
            this_tree = EmptyTree(branch.get_root_id())
297
 
        else:
298
 
            this_revno = last_revno - 1
299
 
            this_revision_id = branch.revision_history()[this_revno]
300
 
            this_tree = branch.revision_tree(this_revision_id)
301
 
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
302
 
 
303
 
 
304
 
def deltas_for_log_forward(branch, which_revs):
305
 
    """Compute deltas for display in forward log.
306
 
 
307
 
    Given a sequence of (revno, revision_id) pairs, return
308
 
    (revno, rev, delta).
309
 
 
310
 
    The delta is from the given revision to the next one in the
311
 
    sequence, which makes sense if the log is being displayed from
312
 
    newest to oldest.
313
 
    """
314
 
    last_revno = last_revision_id = last_tree = None
315
 
    prev_tree = EmptyTree(branch.get_root_id())
316
 
 
317
 
    for revno, revision_id in which_revs:
318
 
        this_tree = branch.revision_tree(revision_id)
319
 
        this_revision = branch.get_revision(revision_id)
320
 
 
321
 
        if not last_revno:
322
 
            if revno == 1:
323
 
                last_tree = EmptyTree(branch.get_root_id())
324
 
            else:
325
 
                last_revno = revno - 1
326
 
                last_revision_id = branch.revision_history()[last_revno]
327
 
                last_tree = branch.revision_tree(last_revision_id)
328
 
 
329
 
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
330
 
 
331
 
        last_revno = revno
332
 
        last_revision = this_revision
333
 
        last_tree = this_tree
 
250
            if not verbose:
 
251
                # although we calculated it, throw it away without display
 
252
                delta = None
 
253
 
 
254
            lf.show(revno, rev, delta)
 
255
        else:
 
256
            lf.show_merge(rev, merge_depth)
 
257
 
 
258
 
 
259
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
 
260
                       include_merges=True):
 
261
    """Produce an iterator of revisions to show
 
262
    :return: an iterator of (revision_id, revno, merge_depth)
 
263
    (if there is no revno for a revision, None is supplied)
 
264
    """
 
265
    if include_merges is False:
 
266
        revision_ids = mainline_revs[1:]
 
267
        if direction == 'reverse':
 
268
            revision_ids.reverse()
 
269
        for revision_id in revision_ids:
 
270
            yield revision_id, rev_nos[revision_id], 0
 
271
        return
 
272
    merge_sorted_revisions = merge_sort(
 
273
        branch.repository.get_revision_graph(mainline_revs[-1]),
 
274
        mainline_revs[-1],
 
275
        mainline_revs)
 
276
 
 
277
    if direction == 'forward':
 
278
        # forward means oldest first.
 
279
        merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
 
280
    elif direction != 'reverse':
 
281
        raise ValueError('invalid direction %r' % direction)
 
282
 
 
283
    revision_history = branch.revision_history()
 
284
 
 
285
    for sequence, rev_id, merge_depth, end_of_merge in merge_sorted_revisions:
 
286
        yield rev_id, rev_nos.get(rev_id), merge_depth
 
287
 
 
288
 
 
289
def reverse_by_depth(merge_sorted_revisions, _depth=0):
 
290
    """Reverse revisions by depth.
 
291
 
 
292
    Revisions with a different depth are sorted as a group with the previous
 
293
    revision of that depth.  There may be no topological justification for this,
 
294
    but it looks much nicer.
 
295
    """
 
296
    zd_revisions = []
 
297
    for val in merge_sorted_revisions:
 
298
        if val[2] == _depth:
 
299
            zd_revisions.append([val])
 
300
        else:
 
301
            assert val[2] > _depth
 
302
            zd_revisions[-1].append(val)
 
303
    for revisions in zd_revisions:
 
304
        if len(revisions) > 1:
 
305
            revisions[1:] = reverse_by_depth(revisions[1:], _depth + 1)
 
306
    zd_revisions.reverse()
 
307
    result = []
 
308
    for chunk in zd_revisions:
 
309
        result.extend(chunk)
 
310
    return result
334
311
 
335
312
 
336
313
class LogFormatter(object):
337
314
    """Abstract class to display log messages."""
 
315
 
338
316
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
339
317
        self.to_file = to_file
340
318
        self.show_ids = show_ids
341
319
        self.show_timezone = show_timezone
342
320
 
343
 
 
344
321
    def show(self, revno, rev, delta):
345
322
        raise NotImplementedError('not implemented in abstract base')
346
323
 
352
329
    def show(self, revno, rev, delta):
353
330
        return self._show_helper(revno=revno, rev=rev, delta=delta)
354
331
 
355
 
    def show_merge(self, rev):
356
 
        return self._show_helper(rev=rev, indent='    ', merged=True, delta=None)
 
332
    def show_merge(self, rev, merge_depth):
 
333
        return self._show_helper(rev=rev, indent='    '*merge_depth, merged=True, delta=None)
357
334
 
358
335
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
359
 
        """Show a revision, either merged or not."""
 
336
        """Show a revision, either merged or not."""
360
337
        from bzrlib.osutils import format_date
361
338
        to_file = self.to_file
362
339
        print >>to_file,  indent+'-' * 60
417
394
            delta.show(to_file, self.show_ids)
418
395
        print >>to_file, ''
419
396
 
 
397
 
420
398
class LineLogFormatter(LogFormatter):
421
399
    def truncate(self, str, max_len):
422
400
        if len(str) <= max_len:
436
414
            return rev.message
437
415
 
438
416
    def show(self, revno, rev, delta):
439
 
        print >> self.to_file, self.log_string(rev, 79) 
 
417
        from bzrlib.osutils import terminal_width
 
418
        print >> self.to_file, self.log_string(revno, rev, terminal_width()-1)
440
419
 
441
 
    def log_string(self, rev, max_chars):
442
 
        out = [self.truncate(self.short_committer(rev), 20)]
 
420
    def log_string(self, revno, rev, max_chars):
 
421
        """Format log info into one string. Truncate tail of string
 
422
        :param  revno:      revision number (int) or None.
 
423
                            Revision numbers counts from 1.
 
424
        :param  rev:        revision info object
 
425
        :param  max_chars:  maximum length of resulting string
 
426
        :return:            formatted truncated string
 
427
        """
 
428
        out = []
 
429
        if revno:
 
430
            # show revno only when is not None
 
431
            out.append("%d:" % revno)
 
432
        out.append(self.truncate(self.short_committer(rev), 20))
443
433
        out.append(self.date_string(rev))
444
 
        out.append(self.message(rev).replace('\n', ' '))
 
434
        out.append(rev.get_summary())
445
435
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
446
436
 
 
437
 
447
438
def line_log(rev, max_chars):
448
439
    lf = LineLogFormatter(None)
449
 
    return lf.log_string(rev, max_chars)
 
440
    return lf.log_string(None, rev, max_chars)
450
441
 
451
 
FORMATTERS = {'long': LongLogFormatter,
 
442
FORMATTERS = {
 
443
              'long': LongLogFormatter,
452
444
              'short': ShortLogFormatter,
453
445
              'line': LineLogFormatter,
454
446
              }
455
447
 
 
448
def register_formatter(name, formatter):
 
449
    FORMATTERS[name] = formatter
456
450
 
457
451
def log_formatter(name, *args, **kwargs):
458
452
    """Construct a formatter from arguments.
463
457
    from bzrlib.errors import BzrCommandError
464
458
    try:
465
459
        return FORMATTERS[name](*args, **kwargs)
466
 
    except IndexError:
 
460
    except KeyError:
467
461
        raise BzrCommandError("unknown log formatter: %r" % name)
468
462
 
469
463
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
470
 
    # deprecated; for compatability
 
464
    # deprecated; for compatibility
471
465
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
472
466
    lf.show(revno, rev, delta)
473
467
 
510
504
        to_file.write('*'*60)
511
505
        to_file.write('\nRemoved Revisions:\n')
512
506
        for i in range(base_idx, len(old_rh)):
513
 
            rev = branch.get_revision(old_rh[i])
 
507
            rev = branch.repository.get_revision(old_rh[i])
514
508
            lf.show(i+1, rev, None)
515
509
        to_file.write('*'*60)
516
510
        to_file.write('\n\n')