← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-12-20 16:16:34 UTC
  • mfrom: (3123.5.18 hardlinks)
  • Revision ID: pqm@pqm.ubuntu.com-20071220161634-2kcjb650o21ydko4
Accelerate build_tree using similar workingtrees (abentley)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
59
59
    warn,
60
60
    )
61
61
 
62
 
from bzrlib.lazy_import import lazy_import
63
 
lazy_import(globals(), """
64
 
 
65
62
from bzrlib import (
66
63
    config,
67
 
    errors,
68
 
    repository as _mod_repository,
69
 
    revision as _mod_revision,
70
 
    revisionspec,
71
 
    trace,
72
 
    tsort,
73
 
    )
74
 
""")
75
 
 
76
 
from bzrlib import (
 
64
    lazy_regex,
77
65
    registry,
 
66
    symbol_versioning,
 
67
    )
 
68
from bzrlib.errors import (
 
69
    BzrCommandError,
78
70
    )
79
71
from bzrlib.osutils import (
80
72
    format_date,
81
73
    get_terminal_encoding,
82
74
    terminal_width,
83
75
    )
 
76
from bzrlib.revision import (
 
77
    NULL_REVISION,
 
78
    )
 
79
from bzrlib.revisionspec import (
 
80
    RevisionInfo,
 
81
    )
 
82
from bzrlib.symbol_versioning import (
 
83
    deprecated_method,
 
84
    zero_seventeen,
 
85
    )
 
86
from bzrlib.trace import mutter
 
87
from bzrlib.tsort import (
 
88
    merge_sort,
 
89
    topo_sort,
 
90
    )
84
91
 
85
92
 
86
93
def find_touching_revisions(branch, file_id):
186
193
    finally:
187
194
        branch.unlock()
188
195
 
189
 
 
190
196
def _show_log(branch,
191
197
             lf,
192
198
             specific_fileid=None,
201
207
        warn("not a LogFormatter instance: %r" % lf)
202
208
 
203
209
    if specific_fileid:
204
 
        trace.mutter('get log for file_id %r', specific_fileid)
205
 
    generate_merge_revisions = getattr(lf, 'supports_merge_revisions', False)
206
 
    allow_single_merge_revision = getattr(lf,
207
 
        'supports_single_merge_revision', False)
208
 
    view_revisions = calculate_view_revisions(branch, start_revision,
209
 
                                              end_revision, direction,
210
 
                                              specific_fileid,
211
 
                                              generate_merge_revisions,
212
 
                                              allow_single_merge_revision)
 
210
        mutter('get log for file_id %r', specific_fileid)
 
211
 
213
212
    if search is not None:
214
213
        searchRE = re.compile(search, re.IGNORECASE)
215
214
    else:
216
215
        searchRE = None
217
216
 
218
 
    rev_tag_dict = {}
219
 
    generate_tags = getattr(lf, 'supports_tags', False)
220
 
    if generate_tags:
221
 
        if branch.supports_tags():
222
 
            rev_tag_dict = branch.tags.get_reverse_tag_dict()
223
 
 
224
 
    generate_delta = verbose and getattr(lf, 'supports_delta', False)
225
 
 
226
 
    # now we just print all the revisions
227
 
    log_count = 0
228
 
    for (rev_id, revno, merge_depth), rev, delta in _iter_revisions(
229
 
        branch.repository, view_revisions, generate_delta):
230
 
        if searchRE:
231
 
            if not searchRE.search(rev.message):
232
 
                continue
233
 
 
234
 
        lr = LogRevision(rev, revno, merge_depth, delta,
235
 
                         rev_tag_dict.get(rev_id))
236
 
        lf.log_revision(lr)
237
 
        if limit:
238
 
            log_count += 1
239
 
            if log_count >= limit:
240
 
                break
241
 
 
242
 
 
243
 
def calculate_view_revisions(branch, start_revision, end_revision, direction,
244
 
                             specific_fileid, generate_merge_revisions,
245
 
                             allow_single_merge_revision):
246
 
    if (not generate_merge_revisions and start_revision is end_revision is
247
 
        None and direction == 'reverse' and specific_fileid is None):
248
 
        return _linear_view_revisions(branch)
249
 
 
250
217
    mainline_revs, rev_nos, start_rev_id, end_rev_id = \
251
218
        _get_mainline_revs(branch, start_revision, end_revision)
252
219
    if not mainline_revs:
253
 
        return []
 
220
        return
254
221
 
255
222
    if direction == 'reverse':
256
223
        start_rev_id, end_rev_id = end_rev_id, start_rev_id
257
 
 
 
224
        
 
225
    legacy_lf = getattr(lf, 'log_revision', None) is None
 
226
    if legacy_lf:
 
227
        # pre-0.17 formatters use show for mainline revisions.
 
228
        # how should we show merged revisions ?
 
229
        #   pre-0.11 api: show_merge
 
230
        #   0.11-0.16 api: show_merge_revno
 
231
        show_merge_revno = getattr(lf, 'show_merge_revno', None)
 
232
        show_merge = getattr(lf, 'show_merge', None)
 
233
        if show_merge is None and show_merge_revno is None:
 
234
            # no merged-revno support
 
235
            generate_merge_revisions = False
 
236
        else:
 
237
            generate_merge_revisions = True
 
238
        # tell developers to update their code
 
239
        symbol_versioning.warn('LogFormatters should provide log_revision '
 
240
            'instead of show and show_merge_revno since bzr 0.17.',
 
241
            DeprecationWarning, stacklevel=3)
 
242
    else:
 
243
        generate_merge_revisions = getattr(lf, 'supports_merge_revisions', 
 
244
                                           False)
258
245
    generate_single_revision = False
259
246
    if ((not generate_merge_revisions)
260
247
        and ((start_rev_id and (start_rev_id not in rev_nos))
261
248
            or (end_rev_id and (end_rev_id not in rev_nos)))):
262
249
        generate_single_revision = ((start_rev_id == end_rev_id)
263
 
            and allow_single_merge_revision)
 
250
            and getattr(lf, 'supports_single_merge_revision', False))
264
251
        if not generate_single_revision:
265
 
            raise errors.BzrCommandError('Selected log formatter only supports'
266
 
                ' mainline revisions.')
 
252
            raise BzrCommandError('Selected log formatter only supports '
 
253
                'mainline revisions.')
267
254
        generate_merge_revisions = generate_single_revision
268
255
    view_revs_iter = get_view_revisions(mainline_revs, rev_nos, branch,
269
256
                          direction, include_merges=generate_merge_revisions)
284
271
        min_depth = min([d for r,n,d in view_revisions])
285
272
        if min_depth != 0:
286
273
            view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
287
 
    return view_revisions
288
 
 
289
 
 
290
 
def _linear_view_revisions(branch):
291
 
    start_revno, start_revision_id = branch.last_revision_info()
292
 
    repo = branch.repository
293
 
    revision_ids = repo.iter_reverse_revision_history(start_revision_id)
294
 
    for num, revision_id in enumerate(revision_ids):
295
 
        yield revision_id, str(start_revno - num), 0
296
 
 
297
 
 
298
 
def _iter_revisions(repository, view_revisions, generate_delta):
299
 
    num = 9
300
 
    view_revisions = iter(view_revisions)
301
 
    while True:
302
 
        cur_view_revisions = [d for x, d in zip(range(num), view_revisions)]
303
 
        if len(cur_view_revisions) == 0:
304
 
            break
305
 
        cur_deltas = {}
 
274
        
 
275
    rev_tag_dict = {}
 
276
    generate_tags = getattr(lf, 'supports_tags', False)
 
277
    if generate_tags:
 
278
        if branch.supports_tags():
 
279
            rev_tag_dict = branch.tags.get_reverse_tag_dict()
 
280
 
 
281
    generate_delta = verbose and getattr(lf, 'supports_delta', False)
 
282
 
 
283
    def iter_revisions():
306
284
        # r = revision, n = revno, d = merge depth
307
 
        revision_ids = [r for (r, n, d) in cur_view_revisions]
308
 
        revisions = repository.get_revisions(revision_ids)
309
 
        if generate_delta:
310
 
            deltas = repository.get_deltas_for_revisions(revisions)
311
 
            cur_deltas = dict(izip((r.revision_id for r in revisions),
312
 
                                   deltas))
313
 
        for view_data, revision in izip(cur_view_revisions, revisions):
314
 
            yield view_data, revision, cur_deltas.get(revision.revision_id)
315
 
        num = min(int(num * 1.5), 200)
 
285
        revision_ids = [r for r, n, d in view_revisions]
 
286
        num = 9
 
287
        repository = branch.repository
 
288
        while revision_ids:
 
289
            cur_deltas = {}
 
290
            revisions = repository.get_revisions(revision_ids[:num])
 
291
            if generate_delta:
 
292
                deltas = repository.get_deltas_for_revisions(revisions)
 
293
                cur_deltas = dict(izip((r.revision_id for r in revisions),
 
294
                                       deltas))
 
295
            for revision in revisions:
 
296
                yield revision, cur_deltas.get(revision.revision_id)
 
297
            revision_ids  = revision_ids[num:]
 
298
            num = min(int(num * 1.5), 200)
 
299
 
 
300
    # now we just print all the revisions
 
301
    log_count = 0
 
302
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
 
303
         izip(view_revisions, iter_revisions()):
 
304
 
 
305
        if searchRE:
 
306
            if not searchRE.search(rev.message):
 
307
                continue
 
308
 
 
309
        if not legacy_lf:
 
310
            lr = LogRevision(rev, revno, merge_depth, delta,
 
311
                             rev_tag_dict.get(rev_id))
 
312
            lf.log_revision(lr)
 
313
        else:
 
314
            # support for legacy (pre-0.17) LogFormatters
 
315
            if merge_depth == 0:
 
316
                if generate_tags:
 
317
                    lf.show(revno, rev, delta, rev_tag_dict.get(rev_id))
 
318
                else:
 
319
                    lf.show(revno, rev, delta)
 
320
            else:
 
321
                if show_merge_revno is None:
 
322
                    lf.show_merge(rev, merge_depth)
 
323
                else:
 
324
                    if generate_tags:
 
325
                        lf.show_merge_revno(rev, merge_depth, revno,
 
326
                                            rev_tag_dict.get(rev_id))
 
327
                    else:
 
328
                        lf.show_merge_revno(rev, merge_depth, revno)
 
329
        if limit:
 
330
            log_count += 1
 
331
            if log_count >= limit:
 
332
                break
316
333
 
317
334
 
318
335
def _get_mainline_revs(branch, start_revision, end_revision):
332
349
 
333
350
    :return: A (mainline_revs, rev_nos, start_rev_id, end_rev_id) tuple.
334
351
    """
335
 
    branch_revno, branch_last_revision = branch.last_revision_info()
336
 
    if branch_revno == 0:
 
352
    which_revs = _enumerate_history(branch)
 
353
    if not which_revs:
337
354
        return None, None, None, None
338
355
 
339
356
    # For mainline generation, map start_revision and end_revision to 
346
363
    if start_revision is None:
347
364
        start_revno = 1
348
365
    else:
349
 
        if isinstance(start_revision, revisionspec.RevisionInfo):
 
366
        if isinstance(start_revision,RevisionInfo):
350
367
            start_rev_id = start_revision.rev_id
351
368
            start_revno = start_revision.revno or 1
352
369
        else:
355
372
    
356
373
    end_rev_id = None
357
374
    if end_revision is None:
358
 
        end_revno = branch_revno
 
375
        end_revno = len(which_revs)
359
376
    else:
360
 
        if isinstance(end_revision, revisionspec.RevisionInfo):
 
377
        if isinstance(end_revision,RevisionInfo):
361
378
            end_rev_id = end_revision.rev_id
362
 
            end_revno = end_revision.revno or branch_revno
 
379
            end_revno = end_revision.revno or len(which_revs)
363
380
        else:
364
381
            branch.check_real_revno(end_revision)
365
382
            end_revno = end_revision
366
383
 
367
 
    if ((start_rev_id == _mod_revision.NULL_REVISION)
368
 
        or (end_rev_id == _mod_revision.NULL_REVISION)):
369
 
        raise errors.BzrCommandError('Logging revision 0 is invalid.')
 
384
    if ((start_rev_id == NULL_REVISION)
 
385
        or (end_rev_id == NULL_REVISION)):
 
386
        raise BzrCommandError('Logging revision 0 is invalid.')
370
387
    if start_revno > end_revno:
371
 
        raise errors.BzrCommandError("Start revision must be older than "
372
 
                                     "the end revision.")
 
388
        raise BzrCommandError("Start revision must be older than "
 
389
                              "the end revision.")
373
390
 
374
 
    if end_revno < start_revno:
 
391
    # list indexes are 0-based; revisions are 1-based
 
392
    cut_revs = which_revs[(start_revno-1):(end_revno)]
 
393
    if not cut_revs:
375
394
        return None, None, None, None
376
 
    cur_revno = branch_revno
377
 
    rev_nos = {}
378
 
    mainline_revs = []
379
 
    for revision_id in branch.repository.iter_reverse_revision_history(
380
 
                        branch_last_revision):
381
 
        if cur_revno < start_revno:
382
 
            # We have gone far enough, but we always add 1 more revision
383
 
            rev_nos[revision_id] = cur_revno
384
 
            mainline_revs.append(revision_id)
385
 
            break
386
 
        if cur_revno <= end_revno:
387
 
            rev_nos[revision_id] = cur_revno
388
 
            mainline_revs.append(revision_id)
389
 
        cur_revno -= 1
390
 
    else:
391
 
        # We walked off the edge of all revisions, so we add a 'None' marker
392
 
        mainline_revs.append(None)
393
395
 
394
 
    mainline_revs.reverse()
 
396
    # convert the revision history to a dictionary:
 
397
    rev_nos = dict((k, v) for v, k in cut_revs)
395
398
 
396
399
    # override the mainline to look like the revision history.
 
400
    mainline_revs = [revision_id for index, revision_id in cut_revs]
 
401
    if cut_revs[0][0] == 1:
 
402
        mainline_revs.insert(0, None)
 
403
    else:
 
404
        mainline_revs.insert(0, which_revs[start_revno-2][1])
397
405
    return mainline_revs, rev_nos, start_rev_id, end_rev_id
398
406
 
399
407
 
461
469
    :return: A list of (revision_id, dotted_revno, merge_depth) tuples.
462
470
    """
463
471
    # find all the revisions that change the specific file
 
472
    file_weave = branch.repository.weave_store.get_weave(file_id,
 
473
                branch.repository.get_transaction())
 
474
    weave_modifed_revisions = set(file_weave.versions())
464
475
    # build the ancestry of each revision in the graph
465
476
    # - only listing the ancestors that change the specific file.
466
 
    graph = branch.repository.get_graph()
467
 
    # This asks for all mainline revisions, which means we only have to spider
468
 
    # sideways, rather than depth history. That said, its still size-of-history
469
 
    # and should be addressed.
470
 
    # mainline_revisions always includes an extra revision at the beginning, so
471
 
    # don't request it.
472
 
    parent_map = dict(((key, value) for key, value in
473
 
        graph.iter_ancestry(mainline_revisions[1:]) if value is not None))
474
 
    sorted_rev_list = tsort.topo_sort(parent_map.items())
475
 
    text_keys = [(file_id, rev_id) for rev_id in sorted_rev_list]
476
 
    modified_text_versions = branch.repository.texts.get_parent_map(text_keys)
 
477
    rev_graph = branch.repository.get_revision_graph(mainline_revisions[-1])
 
478
    sorted_rev_list = topo_sort(rev_graph)
477
479
    ancestry = {}
478
480
    for rev in sorted_rev_list:
479
 
        text_key = (file_id, rev)
480
 
        parents = parent_map[rev]
481
 
        if text_key not in modified_text_versions and len(parents) == 1:
 
481
        parents = rev_graph[rev]
 
482
        if rev not in weave_modifed_revisions and len(parents) == 1:
482
483
            # We will not be adding anything new, so just use a reference to
483
484
            # the parent ancestry.
484
485
            rev_ancestry = ancestry[parents[0]]
485
486
        else:
486
487
            rev_ancestry = set()
487
 
            if text_key in modified_text_versions:
 
488
            if rev in weave_modifed_revisions:
488
489
                rev_ancestry.add(rev)
489
490
            for parent in parents:
490
 
                if parent not in ancestry:
491
 
                    # parent is a Ghost, which won't be present in
492
 
                    # sorted_rev_list, but we may access it later, so create an
493
 
                    # empty node for it
494
 
                    ancestry[parent] = set()
495
491
                rev_ancestry = rev_ancestry.union(ancestry[parent])
496
492
        ancestry[rev] = rev_ancestry
497
493
 
498
494
    def is_merging_rev(r):
499
 
        parents = parent_map[r]
 
495
        parents = rev_graph[r]
500
496
        if len(parents) > 1:
501
497
            leftparent = parents[0]
502
498
            for rightparent in parents[1:]:
508
504
    # filter from the view the revisions that did not change or merge 
509
505
    # the specific file
510
506
    return [(r, n, d) for r, n, d in view_revs_iter
511
 
            if (file_id, r) in modified_text_versions or is_merging_rev(r)]
 
507
            if r in weave_modifed_revisions or is_merging_rev(r)]
512
508
 
513
509
 
514
510
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
524
520
        for revision_id in revision_ids:
525
521
            yield revision_id, str(rev_nos[revision_id]), 0
526
522
        return
527
 
    graph = branch.repository.get_graph()
528
 
    # This asks for all mainline revisions, which means we only have to spider
529
 
    # sideways, rather than depth history. That said, its still size-of-history
530
 
    # and should be addressed.
531
 
    # mainline_revisions always includes an extra revision at the beginning, so
532
 
    # don't request it.
533
 
    parent_map = dict(((key, value) for key, value in
534
 
        graph.iter_ancestry(mainline_revs[1:]) if value is not None))
535
 
    # filter out ghosts; merge_sort errors on ghosts.
536
 
    rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
537
 
    merge_sorted_revisions = tsort.merge_sort(
538
 
        rev_graph,
 
523
    merge_sorted_revisions = merge_sort(
 
524
        branch.repository.get_revision_graph(mainline_revs[-1]),
539
525
        mainline_revs[-1],
540
526
        mainline_revs,
541
527
        generate_revno=True)
562
548
        if val[2] == _depth:
563
549
            zd_revisions.append([val])
564
550
        else:
 
551
            assert val[2] > _depth
565
552
            zd_revisions[-1].append(val)
566
553
    for revisions in zd_revisions:
567
554
        if len(revisions) > 1:
612
599
        only relevant if supports_merge_revisions is not True.
613
600
    - supports_tags must be True if this log formatter supports tags.
614
601
        Otherwise the tags attribute may not be populated.
615
 
 
616
 
    Plugins can register functions to show custom revision properties using
617
 
    the properties_handler_registry. The registered function
618
 
    must respect the following interface description:
619
 
        def my_show_properties(properties_dict):
620
 
            # code that returns a dict {'name':'value'} of the properties 
621
 
            # to be shown
622
602
    """
623
603
 
624
604
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
636
616
#        """
637
617
#        raise NotImplementedError('not implemented in abstract base')
638
618
 
 
619
    @deprecated_method(zero_seventeen)
 
620
    def show(self, revno, rev, delta):
 
621
        raise NotImplementedError('not implemented in abstract base')
 
622
 
639
623
    def short_committer(self, rev):
640
624
        name, address = config.parse_username(rev.committer)
641
625
        if name:
648
632
            return name
649
633
        return address
650
634
 
651
 
    def show_properties(self, revision, indent):
652
 
        """Displays the custom properties returned by each registered handler.
653
 
        
654
 
        If a registered handler raises an error it is propagated.
655
 
        """
656
 
        for key, handler in properties_handler_registry.iteritems():
657
 
            for key, value in handler(revision).items():
658
 
                self.to_file.write(indent + key + ': ' + value + '\n')
659
 
 
660
635
 
661
636
class LongLogFormatter(LogFormatter):
662
637
 
664
639
    supports_delta = True
665
640
    supports_tags = True
666
641
 
 
642
    @deprecated_method(zero_seventeen)
 
643
    def show(self, revno, rev, delta, tags=None):
 
644
        lr = LogRevision(rev, revno, 0, delta, tags)
 
645
        return self.log_revision(lr)
 
646
 
 
647
    @deprecated_method(zero_seventeen)
 
648
    def show_merge_revno(self, rev, merge_depth, revno, tags=None):
 
649
        """Show a merged revision rev, with merge_depth and a revno."""
 
650
        lr = LogRevision(rev, revno, merge_depth, tags=tags)
 
651
        return self.log_revision(lr)
 
652
 
667
653
    def log_revision(self, revision):
668
654
        """Log a revision, either merged or not."""
669
655
        indent = '    ' * revision.merge_depth
674
660
        if revision.tags:
675
661
            to_file.write(indent + 'tags: %s\n' % (', '.join(revision.tags)))
676
662
        if self.show_ids:
677
 
            to_file.write(indent + 'revision-id: ' + revision.rev.revision_id)
 
663
            to_file.write(indent + 'revision-id:' + revision.rev.revision_id)
678
664
            to_file.write('\n')
679
665
            for parent_id in revision.rev.parent_ids:
680
666
                to_file.write(indent + 'parent: %s\n' % (parent_id,))
681
 
        self.show_properties(revision.rev, indent)
682
667
 
683
668
        author = revision.rev.properties.get('author', None)
684
669
        if author is not None:
710
695
    supports_delta = True
711
696
    supports_single_merge_revision = True
712
697
 
 
698
    @deprecated_method(zero_seventeen)
 
699
    def show(self, revno, rev, delta):
 
700
        lr = LogRevision(rev, revno, 0, delta)
 
701
        return self.log_revision(lr)
 
702
 
713
703
    def log_revision(self, revision):
714
704
        to_file = self.to_file
 
705
        date_str = format_date(revision.rev.timestamp,
 
706
                               revision.rev.timezone or 0,
 
707
                               self.show_timezone)
715
708
        is_merge = ''
716
709
        if len(revision.rev.parent_ids) > 1:
717
710
            is_merge = ' [merge]'
762
755
        else:
763
756
            return rev.message
764
757
 
 
758
    @deprecated_method(zero_seventeen)
 
759
    def show(self, revno, rev, delta):
 
760
        self.to_file.write(self.log_string(revno, rev, terminal_width()-1))
 
761
        self.to_file.write('\n')
 
762
 
765
763
    def log_revision(self, revision):
766
764
        self.to_file.write(self.log_string(revision.revno, revision.rev,
767
765
                                              self._max_chars))
829
827
    try:
830
828
        return log_formatter_registry.make_formatter(name, *args, **kwargs)
831
829
    except KeyError:
832
 
        raise errors.BzrCommandError("unknown log formatter: %r" % name)
 
830
        raise BzrCommandError("unknown log formatter: %r" % name)
833
831
 
834
832
 
835
833
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
892
890
                 end_revision=len(new_rh),
893
891
                 search=None)
894
892
 
895
 
 
896
 
properties_handler_registry = registry.Registry()