209
209
Logger(branch, rqst).show(lf)
212
# Note: This needs to be kept in sync with the defaults in
212
# Note: This needs to be kept this in sync with the defaults in
213
213
# make_log_request_dict() below
214
214
_DEFAULT_REQUEST_PARAMS = {
215
215
'direction': 'reverse',
217
217
'generate_tags': True,
218
'exclude_common_ancestry': False,
219
218
'_match_using_deltas': True,
223
222
def make_log_request_dict(direction='reverse', specific_fileids=None,
224
start_revision=None, end_revision=None, limit=None,
225
message_search=None, levels=None, generate_tags=True,
227
diff_type=None, _match_using_deltas=True,
228
exclude_common_ancestry=False, match=None,
229
signature=False, omit_merges=False,
223
start_revision=None, end_revision=None, limit=None,
224
message_search=None, levels=1, generate_tags=True, delta_type=None,
225
diff_type=None, _match_using_deltas=True):
231
226
"""Convenience function for making a logging request dictionary.
233
228
Using this function may make code slightly safer by ensuring
272
266
algorithm used for matching specific_fileids. This parameter
273
267
may be removed in the future so bzrlib client code should NOT
276
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
277
range operator or as a graph difference.
279
:param signature: show digital signature information
281
:param match: Dictionary of list of search strings to use when filtering
282
revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
283
the empty string to match any of the preceding properties.
285
:param omit_merges: If True, commits with more than one parent are
289
# Take care of old style message_search parameter
292
if 'message' in match:
293
match['message'].append(message_search)
295
match['message'] = [message_search]
297
match={ 'message': [message_search] }
299
271
'direction': direction,
300
272
'specific_fileids': specific_fileids,
301
273
'start_revision': start_revision,
302
274
'end_revision': end_revision,
276
'message_search': message_search,
304
277
'levels': levels,
305
278
'generate_tags': generate_tags,
306
279
'delta_type': delta_type,
307
280
'diff_type': diff_type,
308
'exclude_common_ancestry': exclude_common_ancestry,
309
'signature': signature,
311
'omit_merges': omit_merges,
312
281
# Add 'private' attributes for features that may be deprecated
313
282
'_match_using_deltas': _match_using_deltas,
317
286
def _apply_log_request_defaults(rqst):
318
287
"""Apply default values to a request dictionary."""
319
result = _DEFAULT_REQUEST_PARAMS.copy()
288
result = _DEFAULT_REQUEST_PARAMS
321
290
result.update(rqst)
325
def format_signature_validity(rev_id, repo):
326
"""get the signature validity
328
:param rev_id: revision id to validate
329
:param repo: repository of revision
330
:return: human readable string to print to log
332
from bzrlib import gpg
334
gpg_strategy = gpg.GPGStrategy(None)
335
result = repo.verify_revision_signature(rev_id, gpg_strategy)
336
if result[0] == gpg.SIGNATURE_VALID:
337
return "valid signature from {0}".format(result[1])
338
if result[0] == gpg.SIGNATURE_KEY_MISSING:
339
return "unknown key {0}".format(result[1])
340
if result[0] == gpg.SIGNATURE_NOT_VALID:
341
return "invalid signature!"
342
if result[0] == gpg.SIGNATURE_NOT_SIGNED:
343
return "no signature"
346
294
class LogGenerator(object):
347
295
"""A generator of log revisions."""
393
341
# Tweak the LogRequest based on what the LogFormatter can handle.
394
342
# (There's no point generating stuff if the formatter can't display it.)
396
if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
397
# user didn't specify levels, use whatever the LF can handle:
398
rqst['levels'] = lf.get_levels()
344
rqst['levels'] = lf.get_levels()
400
345
if not getattr(lf, 'supports_tags', False):
401
346
rqst['generate_tags'] = False
402
347
if not getattr(lf, 'supports_delta', False):
403
348
rqst['delta_type'] = None
404
349
if not getattr(lf, 'supports_diff', False):
405
350
rqst['diff_type'] = None
406
if not getattr(lf, 'supports_signatures', False):
407
rqst['signature'] = False
409
352
# Find and print the interesting revisions
410
353
generator = self._generator_factory(self.branch, rqst)
441
384
:return: An iterator yielding LogRevision objects.
444
levels = rqst.get('levels')
445
limit = rqst.get('limit')
446
diff_type = rqst.get('diff_type')
447
show_signature = rqst.get('signature')
448
omit_merges = rqst.get('omit_merges')
450
388
revision_iterator = self._create_log_revision_iterator()
451
389
for revs in revision_iterator:
452
390
for (rev_id, revno, merge_depth), rev, delta in revs:
453
391
# 0 levels means show everything; merge_depth counts from 0
392
levels = rqst.get('levels')
454
393
if levels != 0 and merge_depth >= levels:
456
if omit_merges and len(rev.parent_ids) > 1:
458
if diff_type is None:
461
diff = self._format_diff(rev, rev_id, diff_type)
463
signature = format_signature_validity(rev_id,
464
self.branch.repository)
395
diff = self._format_diff(rev, rev_id)
467
396
yield LogRevision(rev, revno, merge_depth, delta,
468
self.rev_tag_dict.get(rev_id), diff, signature)
397
self.rev_tag_dict.get(rev_id), diff)
398
limit = rqst.get('limit')
471
401
if log_count >= limit:
474
def _format_diff(self, rev, rev_id, diff_type):
404
def _format_diff(self, rev, rev_id):
405
diff_type = self.rqst.get('diff_type')
406
if diff_type is None:
475
408
repo = self.branch.repository
476
409
if len(rev.parent_ids) == 0:
477
410
ancestor_id = _mod_revision.NULL_REVISION
517
449
generate_merge_revisions = rqst.get('levels') != 1
518
450
delayed_graph_generation = not rqst.get('specific_fileids') and (
519
451
rqst.get('limit') or self.start_rev_id or self.end_rev_id)
520
view_revisions = _calc_view_revisions(
521
self.branch, self.start_rev_id, self.end_rev_id,
522
rqst.get('direction'),
523
generate_merge_revisions=generate_merge_revisions,
524
delayed_graph_generation=delayed_graph_generation,
525
exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
452
view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
453
self.end_rev_id, rqst.get('direction'), generate_merge_revisions,
454
delayed_graph_generation=delayed_graph_generation)
527
456
# Apply the other filters
528
457
return make_log_rev_iterator(self.branch, view_revisions,
529
rqst.get('delta_type'), rqst.get('match'),
458
rqst.get('delta_type'), rqst.get('message_search'),
530
459
file_ids=rqst.get('specific_fileids'),
531
460
direction=rqst.get('direction'))
535
464
# Note that we always generate the merge revisions because
536
465
# filter_revisions_touching_file_id() requires them ...
538
view_revisions = _calc_view_revisions(
539
self.branch, self.start_rev_id, self.end_rev_id,
540
rqst.get('direction'), generate_merge_revisions=True,
541
exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
467
view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
468
self.end_rev_id, rqst.get('direction'), True)
542
469
if not isinstance(view_revisions, list):
543
470
view_revisions = list(view_revisions)
544
471
view_revisions = _filter_revisions_touching_file_id(self.branch,
545
472
rqst.get('specific_fileids')[0], view_revisions,
546
473
include_merges=rqst.get('levels') != 1)
547
474
return make_log_rev_iterator(self.branch, view_revisions,
548
rqst.get('delta_type'), rqst.get('match'))
475
rqst.get('delta_type'), rqst.get('message_search'))
551
478
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
552
generate_merge_revisions,
553
delayed_graph_generation=False,
554
exclude_common_ancestry=False,
479
generate_merge_revisions, delayed_graph_generation=False):
556
480
"""Calculate the revisions to view.
558
482
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
559
483
a list of the same tuples.
561
if (exclude_common_ancestry and start_rev_id == end_rev_id):
562
raise errors.BzrCommandError(gettext(
563
'--exclude-common-ancestry requires two different revisions'))
564
if direction not in ('reverse', 'forward'):
565
raise ValueError(gettext('invalid direction %r') % direction)
566
485
br_revno, br_rev_id = branch.last_revision_info()
567
486
if br_revno == 0:
570
if (end_rev_id and start_rev_id == end_rev_id
571
and (not generate_merge_revisions
572
or not _has_merges(branch, end_rev_id))):
573
# If a single revision is requested, check we can handle it
574
return _generate_one_revision(branch, end_rev_id, br_rev_id,
489
# If a single revision is requested, check we can handle it
490
generate_single_revision = (end_rev_id and start_rev_id == end_rev_id and
491
(not generate_merge_revisions or not _has_merges(branch, end_rev_id)))
492
if generate_single_revision:
493
return _generate_one_revision(branch, end_rev_id, br_rev_id, br_revno)
495
# If we only want to see linear revisions, we can iterate ...
576
496
if not generate_merge_revisions:
578
# If we only want to see linear revisions, we can iterate ...
579
iter_revs = _linear_view_revisions(
580
branch, start_rev_id, end_rev_id,
581
exclude_common_ancestry=exclude_common_ancestry)
582
# If a start limit was given and it's not obviously an
583
# ancestor of the end limit, check it before outputting anything
584
if (direction == 'forward'
585
or (start_rev_id and not _is_obvious_ancestor(
586
branch, start_rev_id, end_rev_id))):
587
iter_revs = list(iter_revs)
588
if direction == 'forward':
589
iter_revs = reversed(iter_revs)
591
except _StartNotLinearAncestor:
592
# Switch to the slower implementation that may be able to find a
593
# non-obvious ancestor out of the left-hand history.
595
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
596
direction, delayed_graph_generation,
597
exclude_common_ancestry)
598
if direction == 'forward':
599
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
497
return _generate_flat_revisions(branch, start_rev_id, end_rev_id,
500
return _generate_all_revisions(branch, start_rev_id, end_rev_id,
501
direction, delayed_graph_generation)
603
504
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):
606
507
return [(br_rev_id, br_revno, 0)]
608
revno_str = _compute_revno_str(branch, rev_id)
509
revno = branch.revision_id_to_dotted_revno(rev_id)
510
revno_str = '.'.join(str(n) for n in revno)
609
511
return [(rev_id, revno_str, 0)]
514
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction):
515
result = _linear_view_revisions(branch, start_rev_id, end_rev_id)
516
# If a start limit was given and it's not obviously an
517
# ancestor of the end limit, check it before outputting anything
518
if direction == 'forward' or (start_rev_id
519
and not _is_obvious_ancestor(branch, start_rev_id, end_rev_id)):
521
result = list(result)
522
except _StartNotLinearAncestor:
523
raise errors.BzrCommandError('Start revision not found in'
524
' left-hand history of end revision.')
525
if direction == 'forward':
526
result = reversed(result)
612
530
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
613
delayed_graph_generation,
614
exclude_common_ancestry=False):
531
delayed_graph_generation):
615
532
# On large trees, generating the merge graph can take 30-60 seconds
616
533
# so we delay doing it until a merge is detected, incrementally
617
534
# returning initial (non-merge) revisions while we can.
619
# The above is only true for old formats (<= 0.92), for newer formats, a
620
# couple of seconds only should be needed to load the whole graph and the
621
# other graph operations needed are even faster than that -- vila 100201
622
535
initial_revisions = []
623
536
if delayed_graph_generation:
625
for rev_id, revno, depth in _linear_view_revisions(
626
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
538
for rev_id, revno, depth in \
539
_linear_view_revisions(branch, start_rev_id, end_rev_id):
627
540
if _has_merges(branch, rev_id):
628
# The end_rev_id can be nested down somewhere. We need an
629
# explicit ancestry check. There is an ambiguity here as we
630
# may not raise _StartNotLinearAncestor for a revision that
631
# is an ancestor but not a *linear* one. But since we have
632
# loaded the graph to do the check (or calculate a dotted
633
# revno), we may as well accept to show the log... We need
634
# the check only if start_rev_id is not None as all
635
# revisions have _mod_revision.NULL_REVISION as an ancestor
637
graph = branch.repository.get_graph()
638
if (start_rev_id is not None
639
and not graph.is_ancestor(start_rev_id, end_rev_id)):
640
raise _StartNotLinearAncestor()
641
# Since we collected the revisions so far, we need to
643
541
end_rev_id = rev_id
646
544
initial_revisions.append((rev_id, revno, depth))
648
546
# No merged revisions found
649
return initial_revisions
547
if direction == 'reverse':
548
return initial_revisions
549
elif direction == 'forward':
550
return reversed(initial_revisions)
552
raise ValueError('invalid direction %r' % direction)
650
553
except _StartNotLinearAncestor:
651
554
# A merge was never detected so the lower revision limit can't
652
555
# be nested down somewhere
653
raise errors.BzrCommandError(gettext('Start revision not found in'
654
' history of end revision.'))
656
# We exit the loop above because we encounter a revision with merges, from
657
# this revision, we need to switch to _graph_view_revisions.
556
raise errors.BzrCommandError('Start revision not found in'
557
' history of end revision.')
659
559
# A log including nested merges is required. If the direction is reverse,
660
560
# we rebase the initial merge depths so that the development line is
663
563
# indented at the end seems slightly nicer in that case.
664
564
view_revisions = chain(iter(initial_revisions),
665
565
_graph_view_revisions(branch, start_rev_id, end_rev_id,
666
rebase_initial_depths=(direction == 'reverse'),
667
exclude_common_ancestry=exclude_common_ancestry))
668
return view_revisions
566
rebase_initial_depths=direction == 'reverse'))
567
if direction == 'reverse':
568
return view_revisions
569
elif direction == 'forward':
570
# Forward means oldest first, adjusting for depth.
571
view_revisions = reverse_by_depth(list(view_revisions))
572
return _rebase_merge_depth(view_revisions)
574
raise ValueError('invalid direction %r' % direction)
671
577
def _has_merges(branch, rev_id):
674
580
return len(parents) > 1
677
def _compute_revno_str(branch, rev_id):
678
"""Compute the revno string from a rev_id.
680
:return: The revno string, or None if the revision is not in the supplied
684
revno = branch.revision_id_to_dotted_revno(rev_id)
685
except errors.NoSuchRevision:
686
# The revision must be outside of this branch
689
return '.'.join(str(n) for n in revno)
692
583
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
693
584
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
694
585
if start_rev_id and end_rev_id:
696
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
697
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
698
except errors.NoSuchRevision:
699
# one or both is not in the branch; not obvious
586
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
587
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
701
588
if len(start_dotted) == 1 and len(end_dotted) == 1:
702
589
# both on mainline
703
590
return start_dotted[0] <= end_dotted[0]
711
# if either start or end is not specified then we use either the first or
712
# the last revision and *they* are obvious ancestors.
716
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
717
exclude_common_ancestry=False):
601
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
718
602
"""Calculate a sequence of revisions to view, newest to oldest.
720
604
:param start_rev_id: the lower revision-id
721
605
:param end_rev_id: the upper revision-id
722
:param exclude_common_ancestry: Whether the start_rev_id should be part of
723
the iterated revisions.
724
606
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
725
607
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
726
is not found walking the left-hand history
608
is not found walking the left-hand history
728
610
br_revno, br_rev_id = branch.last_revision_info()
729
611
repo = branch.repository
730
graph = repo.get_graph()
731
612
if start_rev_id is None and end_rev_id is None:
732
613
cur_revno = br_revno
733
for revision_id in graph.iter_lefthand_ancestry(br_rev_id,
734
(_mod_revision.NULL_REVISION,)):
614
for revision_id in repo.iter_reverse_revision_history(br_rev_id):
735
615
yield revision_id, str(cur_revno), 0
738
618
if end_rev_id is None:
739
619
end_rev_id = br_rev_id
740
620
found_start = start_rev_id is None
741
for revision_id in graph.iter_lefthand_ancestry(end_rev_id,
742
(_mod_revision.NULL_REVISION,)):
743
revno_str = _compute_revno_str(branch, revision_id)
621
for revision_id in repo.iter_reverse_revision_history(end_rev_id):
622
revno = branch.revision_id_to_dotted_revno(revision_id)
623
revno_str = '.'.join(str(n) for n in revno)
744
624
if not found_start and revision_id == start_rev_id:
745
if not exclude_common_ancestry:
746
yield revision_id, revno_str, 0
625
yield revision_id, revno_str, 0
747
626
found_start = True
788
662
depth_adjustment = merge_depth
789
663
if depth_adjustment:
790
664
if merge_depth < depth_adjustment:
791
# From now on we reduce the depth adjustement, this can be
792
# surprising for users. The alternative requires two passes
793
# which breaks the fast display of the first revision
795
665
depth_adjustment = merge_depth
796
666
merge_depth -= depth_adjustment
797
667
yield rev_id, '.'.join(map(str, revno)), merge_depth
670
def calculate_view_revisions(branch, start_revision, end_revision, direction,
671
specific_fileid, generate_merge_revisions):
672
"""Calculate the revisions to view.
674
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
675
a list of the same tuples.
677
# This method is no longer called by the main code path.
678
# It is retained for API compatibility and may be deprecated
680
start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
682
view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
683
direction, generate_merge_revisions or specific_fileid))
685
view_revisions = _filter_revisions_touching_file_id(branch,
686
specific_fileid, view_revisions,
687
include_merges=generate_merge_revisions)
688
return _rebase_merge_depth(view_revisions)
800
691
def _rebase_merge_depth(view_revisions):
801
692
"""Adjust depths upwards so the top level is 0."""
802
693
# If either the first or last revision have a merge_depth of 0, we're done
846
737
return log_rev_iterator
849
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
740
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
850
741
"""Create a filtered iterator of log_rev_iterator matching on a regex.
852
743
:param branch: The branch being logged.
853
744
:param generate_delta: Whether to generate a delta for each revision.
854
:param match: A dictionary with properties as keys and lists of strings
855
as values. To match, a revision may match any of the supplied strings
856
within a single property but must match at least one string for each
745
:param search: A user text search string.
858
746
:param log_rev_iterator: An input iterator containing all revisions that
859
747
could be displayed, in lists.
860
748
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
864
752
return log_rev_iterator
865
searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
866
for (k,v) in match.iteritems()]
867
return _filter_re(searchRE, log_rev_iterator)
870
def _filter_re(searchRE, log_rev_iterator):
753
searchRE = re_compile_checked(search, re.IGNORECASE,
754
'log message filter')
755
return _filter_message_re(searchRE, log_rev_iterator)
758
def _filter_message_re(searchRE, log_rev_iterator):
871
759
for revs in log_rev_iterator:
872
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
876
def _match_filter(searchRE, rev):
878
'message': (rev.message,),
879
'committer': (rev.committer,),
880
'author': (rev.get_apparent_authors()),
881
'bugs': list(rev.iter_bugs())
883
strings[''] = [item for inner_list in strings.itervalues()
884
for item in inner_list]
885
for (k,v) in searchRE:
886
if k in strings and not _match_any_filter(strings[k], v):
890
def _match_any_filter(strings, res):
891
return any([filter(None, map(re.search, strings)) for re in res])
761
for (rev_id, revno, merge_depth), rev, delta in revs:
762
if searchRE.search(rev.message):
763
new_revs.append(((rev_id, revno, merge_depth), rev, delta))
893
767
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
894
768
fileids=None, direction='reverse'):
1127
1002
if ((start_rev_id == _mod_revision.NULL_REVISION)
1128
1003
or (end_rev_id == _mod_revision.NULL_REVISION)):
1129
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1004
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1130
1005
if start_revno > end_revno:
1131
raise errors.BzrCommandError(gettext("Start revision must be older "
1132
"than the end revision."))
1006
raise errors.BzrCommandError("Start revision must be older than "
1007
"the end revision.")
1134
1009
if end_revno < start_revno:
1135
1010
return None, None, None, None
1136
1011
cur_revno = branch_revno
1138
1013
mainline_revs = []
1139
graph = branch.repository.get_graph()
1140
for revision_id in graph.iter_lefthand_ancestry(
1141
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1014
for revision_id in branch.repository.iter_reverse_revision_history(
1015
branch_last_revision):
1142
1016
if cur_revno < start_revno:
1143
1017
# We have gone far enough, but we always add 1 more revision
1144
1018
rev_nos[revision_id] = cur_revno
1158
1032
return mainline_revs, rev_nos, start_rev_id, end_rev_id
1035
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1036
"""Filter view_revisions based on revision ranges.
1038
:param view_revisions: A list of (revision_id, dotted_revno, merge_depth)
1039
tuples to be filtered.
1041
:param start_rev_id: If not NONE specifies the first revision to be logged.
1042
If NONE then all revisions up to the end_rev_id are logged.
1044
:param end_rev_id: If not NONE specifies the last revision to be logged.
1045
If NONE then all revisions up to the end of the log are logged.
1047
:return: The filtered view_revisions.
1049
# This method is no longer called by the main code path.
1050
# It may be removed soon. IGC 20090127
1051
if start_rev_id or end_rev_id:
1052
revision_ids = [r for r, n, d in view_revisions]
1054
start_index = revision_ids.index(start_rev_id)
1057
if start_rev_id == end_rev_id:
1058
end_index = start_index
1061
end_index = revision_ids.index(end_rev_id)
1063
end_index = len(view_revisions) - 1
1064
# To include the revisions merged into the last revision,
1065
# extend end_rev_id down to, but not including, the next rev
1066
# with the same or lesser merge_depth
1067
end_merge_depth = view_revisions[end_index][2]
1069
for index in xrange(end_index+1, len(view_revisions)+1):
1070
if view_revisions[index][2] <= end_merge_depth:
1071
end_index = index - 1
1074
# if the search falls off the end then log to the end as well
1075
end_index = len(view_revisions) - 1
1076
view_revisions = view_revisions[start_index:end_index+1]
1077
return view_revisions
1161
1080
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1162
1081
include_merges=True):
1163
1082
r"""Return the list of revision ids which touch a given file id.
1162
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1163
include_merges=True):
1164
"""Produce an iterator of revisions to show
1165
:return: an iterator of (revision_id, revno, merge_depth)
1166
(if there is no revno for a revision, None is supplied)
1168
# This method is no longer called by the main code path.
1169
# It is retained for API compatibility and may be deprecated
1170
# soon. IGC 20090127
1171
if not include_merges:
1172
revision_ids = mainline_revs[1:]
1173
if direction == 'reverse':
1174
revision_ids.reverse()
1175
for revision_id in revision_ids:
1176
yield revision_id, str(rev_nos[revision_id]), 0
1178
graph = branch.repository.get_graph()
1179
# This asks for all mainline revisions, which means we only have to spider
1180
# sideways, rather than depth history. That said, its still size-of-history
1181
# and should be addressed.
1182
# mainline_revisions always includes an extra revision at the beginning, so
1184
parent_map = dict(((key, value) for key, value in
1185
graph.iter_ancestry(mainline_revs[1:]) if value is not None))
1186
# filter out ghosts; merge_sort errors on ghosts.
1187
rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
1188
merge_sorted_revisions = tsort.merge_sort(
1192
generate_revno=True)
1194
if direction == 'forward':
1195
# forward means oldest first.
1196
merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
1197
elif direction != 'reverse':
1198
raise ValueError('invalid direction %r' % direction)
1200
for (sequence, rev_id, merge_depth, revno, end_of_merge
1201
) in merge_sorted_revisions:
1202
yield rev_id, '.'.join(map(str, revno)), merge_depth
1245
1205
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1246
1206
"""Reverse revisions by depth.
1307
1263
to indicate which LogRevision attributes it supports:
1309
1265
- supports_delta must be True if this log formatter supports delta.
1310
Otherwise the delta attribute may not be populated. The 'delta_format'
1311
attribute describes whether the 'short_status' format (1) or the long
1312
one (2) should be used.
1266
Otherwise the delta attribute may not be populated. The 'delta_format'
1267
attribute describes whether the 'short_status' format (1) or the long
1268
one (2) should be used.
1314
1270
- supports_merge_revisions must be True if this log formatter supports
1315
merge revisions. If not, then only mainline revisions will be passed
1271
merge revisions. If not, then only mainline revisions will be passed
1318
1274
- preferred_levels is the number of levels this formatter defaults to.
1319
The default value is zero meaning display all levels.
1320
This value is only relevant if supports_merge_revisions is True.
1275
The default value is zero meaning display all levels.
1276
This value is only relevant if supports_merge_revisions is True.
1322
1278
- supports_tags must be True if this log formatter supports tags.
1323
Otherwise the tags attribute may not be populated.
1279
Otherwise the tags attribute may not be populated.
1325
1281
- supports_diff must be True if this log formatter supports diffs.
1326
Otherwise the diff attribute may not be populated.
1328
- supports_signatures must be True if this log formatter supports GPG
1282
Otherwise the diff attribute may not be populated.
1331
1284
Plugins can register functions to show custom revision properties using
1332
1285
the properties_handler_registry. The registered function
1333
must respect the following interface description::
1286
must respect the following interface description:
1335
1287
def my_show_properties(properties_dict):
1336
1288
# code that returns a dict {'name':'value'} of the properties
1339
1291
preferred_levels = 0
1341
1293
def __init__(self, to_file, show_ids=False, show_timezone='original',
1342
delta_format=None, levels=None, show_advice=False,
1343
to_exact_file=None, author_list_handler=None):
1294
delta_format=None, levels=None, show_advice=False):
1344
1295
"""Create a LogFormatter.
1346
1297
:param to_file: the file to output to
1347
:param to_exact_file: if set, gives an output stream to which
1348
non-Unicode diffs are written.
1349
1298
:param show_ids: if True, revision-ids are to be displayed
1350
1299
:param show_timezone: the timezone to use
1351
1300
:param delta_format: the level of delta information to display
1354
1303
let the log formatter decide.
1355
1304
:param show_advice: whether to show advice at the end of the
1357
:param author_list_handler: callable generating a list of
1358
authors to display for a given revision
1360
1307
self.to_file = to_file
1361
1308
# 'exact' stream used to show diff, it should print content 'as is'
1362
1309
# and should not try to decode/encode it to unicode to avoid bug #328007
1363
if to_exact_file is not None:
1364
self.to_exact_file = to_exact_file
1366
# XXX: somewhat hacky; this assumes it's a codec writer; it's better
1367
# for code that expects to get diffs to pass in the exact file
1369
self.to_exact_file = getattr(to_file, 'stream', to_file)
1310
self.to_exact_file = getattr(to_file, 'stream', to_file)
1370
1311
self.show_ids = show_ids
1371
1312
self.show_timezone = show_timezone
1372
1313
if delta_format is None:
1416
1356
def short_author(self, rev):
1417
return self.authors(rev, 'first', short=True, sep=', ')
1419
def authors(self, rev, who, short=False, sep=None):
1420
"""Generate list of authors, taking --authors option into account.
1422
The caller has to specify the name of a author list handler,
1423
as provided by the author list registry, using the ``who``
1424
argument. That name only sets a default, though: when the
1425
user selected a different author list generation using the
1426
``--authors`` command line switch, as represented by the
1427
``author_list_handler`` constructor argument, that value takes
1430
:param rev: The revision for which to generate the list of authors.
1431
:param who: Name of the default handler.
1432
:param short: Whether to shorten names to either name or address.
1433
:param sep: What separator to use for automatic concatenation.
1435
if self._author_list_handler is not None:
1436
# The user did specify --authors, which overrides the default
1437
author_list_handler = self._author_list_handler
1439
# The user didn't specify --authors, so we use the caller's default
1440
author_list_handler = author_list_registry.get(who)
1441
names = author_list_handler(rev)
1443
for i in range(len(names)):
1444
name, address = config.parse_username(names[i])
1450
names = sep.join(names)
1357
name, address = config.parse_username(rev.get_apparent_authors()[0])
1453
1362
def merge_marker(self, revision):
1454
1363
"""Get the merge marker to include in the output or '' if none."""
1461
def show_properties(self, revision, indent):
1462
"""Displays the custom properties returned by each registered handler.
1464
If a registered handler raises an error it is propagated.
1466
for line in self.custom_properties(revision):
1467
self.to_file.write("%s%s\n" % (indent, line))
1469
def custom_properties(self, revision):
1470
"""Format the custom properties returned by each registered handler.
1472
If a registered handler raises an error it is propagated.
1474
:return: a list of formatted lines (excluding trailing newlines)
1476
lines = self._foreign_info_properties(revision)
1477
for key, handler in properties_handler_registry.iteritems():
1478
lines.extend(self._format_properties(handler(revision)))
1481
def _foreign_info_properties(self, rev):
1370
def show_foreign_info(self, rev, indent):
1482
1371
"""Custom log displayer for foreign revision identifiers.
1484
1373
:param rev: Revision object.
1486
1375
# Revision comes directly from a foreign repository
1487
1376
if isinstance(rev, foreign.ForeignRevision):
1488
return self._format_properties(
1489
rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
1377
self._write_properties(indent, rev.mapping.vcs.show_foreign_revid(
1491
1381
# Imported foreign revision revision ids always contain :
1492
1382
if not ":" in rev.revision_id:
1495
1385
# Revision was once imported from a foreign repository
1497
1387
foreign_revid, mapping = \
1498
1388
foreign.foreign_vcs_registry.parse_revision_id(rev.revision_id)
1499
1389
except errors.InvalidRevisionId:
1502
return self._format_properties(
1392
self._write_properties(indent,
1503
1393
mapping.vcs.show_foreign_revid(foreign_revid))
1505
def _format_properties(self, properties):
1395
def show_properties(self, revision, indent):
1396
"""Displays the custom properties returned by each registered handler.
1398
If a registered handler raises an error it is propagated.
1400
for key, handler in properties_handler_registry.iteritems():
1401
self._write_properties(indent, handler(revision))
1403
def _write_properties(self, indent, properties):
1507
1404
for key, value in properties.items():
1508
lines.append(key + ': ' + value)
1405
self.to_file.write(indent + key + ': ' + value + '\n')
1511
1407
def show_diff(self, to_file, diff, indent):
1512
1408
for l in diff.rstrip().split('\n'):
1513
1409
to_file.write(indent + '%s\n' % (l,))
1516
# Separator between revisions in long format
1517
_LONG_SEP = '-' * 60
1520
1412
class LongLogFormatter(LogFormatter):
1522
1414
supports_merge_revisions = True
1524
1416
supports_delta = True
1525
1417
supports_tags = True
1526
1418
supports_diff = True
1527
supports_signatures = True
1529
def __init__(self, *args, **kwargs):
1530
super(LongLogFormatter, self).__init__(*args, **kwargs)
1531
if self.show_timezone == 'original':
1532
self.date_string = self._date_string_original_timezone
1534
self.date_string = self._date_string_with_timezone
1536
def _date_string_with_timezone(self, rev):
1537
return format_date(rev.timestamp, rev.timezone or 0,
1540
def _date_string_original_timezone(self, rev):
1541
return format_date_with_offset_in_original_timezone(rev.timestamp,
1544
1420
def log_revision(self, revision):
1545
1421
"""Log a revision, either merged or not."""
1546
1422
indent = ' ' * revision.merge_depth
1423
to_file = self.to_file
1424
to_file.write(indent + '-' * 60 + '\n')
1548
1425
if revision.revno is not None:
1549
lines.append('revno: %s%s' % (revision.revno,
1426
to_file.write(indent + 'revno: %s%s\n' % (revision.revno,
1550
1427
self.merge_marker(revision)))
1551
1428
if revision.tags:
1552
lines.append('tags: %s' % (', '.join(revision.tags)))
1553
if self.show_ids or revision.revno is None:
1554
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1429
to_file.write(indent + 'tags: %s\n' % (', '.join(revision.tags)))
1555
1430
if self.show_ids:
1431
to_file.write(indent + 'revision-id: ' + revision.rev.revision_id)
1556
1433
for parent_id in revision.rev.parent_ids:
1557
lines.append('parent: %s' % (parent_id,))
1558
lines.extend(self.custom_properties(revision.rev))
1434
to_file.write(indent + 'parent: %s\n' % (parent_id,))
1435
self.show_foreign_info(revision.rev, indent)
1436
self.show_properties(revision.rev, indent)
1560
1438
committer = revision.rev.committer
1561
authors = self.authors(revision.rev, 'all')
1439
authors = revision.rev.get_apparent_authors()
1562
1440
if authors != [committer]:
1563
lines.append('author: %s' % (", ".join(authors),))
1564
lines.append('committer: %s' % (committer,))
1441
to_file.write(indent + 'author: %s\n' % (", ".join(authors),))
1442
to_file.write(indent + 'committer: %s\n' % (committer,))
1566
1444
branch_nick = revision.rev.properties.get('branch-nick', None)
1567
1445
if branch_nick is not None:
1568
lines.append('branch nick: %s' % (branch_nick,))
1570
lines.append('timestamp: %s' % (self.date_string(revision.rev),))
1572
if revision.signature is not None:
1573
lines.append('signature: ' + revision.signature)
1575
lines.append('message:')
1446
to_file.write(indent + 'branch nick: %s\n' % (branch_nick,))
1448
date_str = format_date(revision.rev.timestamp,
1449
revision.rev.timezone or 0,
1451
to_file.write(indent + 'timestamp: %s\n' % (date_str,))
1453
to_file.write(indent + 'message:\n')
1576
1454
if not revision.rev.message:
1577
lines.append(' (no message)')
1455
to_file.write(indent + ' (no message)\n')
1579
1457
message = revision.rev.message.rstrip('\r\n')
1580
1458
for l in message.split('\n'):
1581
lines.append(' %s' % (l,))
1583
# Dump the output, appending the delta and diff if requested
1584
to_file = self.to_file
1585
to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1459
to_file.write(indent + ' %s\n' % (l,))
1586
1460
if revision.delta is not None:
1587
# Use the standard status output to display changes
1588
from bzrlib.delta import report_delta
1589
report_delta(to_file, revision.delta, short_status=False,
1590
show_ids=self.show_ids, indent=indent)
1461
# We don't respect delta_format for compatibility
1462
revision.delta.show(to_file, self.show_ids, indent=indent,
1591
1464
if revision.diff is not None:
1592
1465
to_file.write(indent + 'diff:\n')
1594
1466
# Note: we explicitly don't indent the diff (relative to the
1595
1467
# revision information) so that the output can be fed to patch -p0
1596
1468
self.show_diff(self.to_exact_file, revision.diff, indent)
1597
self.to_exact_file.flush()
1599
1470
def get_advice_separator(self):
1600
1471
"""Get the text separating the log from the closing advice."""
1638
1509
if revision.tags:
1639
1510
tags = ' {%s}' % (', '.join(revision.tags))
1640
1511
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1641
revision.revno or "", self.short_author(revision.rev),
1512
revision.revno, self.short_author(revision.rev),
1642
1513
format_date(revision.rev.timestamp,
1643
1514
revision.rev.timezone or 0,
1644
1515
self.show_timezone, date_fmt="%Y-%m-%d",
1645
1516
show_offset=False),
1646
1517
tags, self.merge_marker(revision)))
1518
self.show_foreign_info(revision.rev, indent+offset)
1647
1519
self.show_properties(revision.rev, indent+offset)
1648
if self.show_ids or revision.revno is None:
1649
1521
to_file.write(indent + offset + 'revision-id:%s\n'
1650
1522
% (revision.rev.revision_id,))
1651
1523
if not revision.rev.message:
1705
1570
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1706
1571
"""Format log info into one string. Truncate tail of string
1708
:param revno: revision number or None.
1709
Revision numbers counts from 1.
1710
:param rev: revision object
1711
:param max_chars: maximum length of resulting string
1712
:param tags: list of tags or None
1713
:param prefix: string to prefix each line
1714
:return: formatted truncated string
1572
:param revno: revision number or None.
1573
Revision numbers counts from 1.
1574
:param rev: revision object
1575
:param max_chars: maximum length of resulting string
1576
:param tags: list of tags or None
1577
:param prefix: string to prefix each line
1578
:return: formatted truncated string
1718
1582
# show revno only when is not None
1719
1583
out.append("%s:" % revno)
1720
if max_chars is not None:
1721
out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
1723
out.append(self.short_author(rev))
1584
out.append(self.truncate(self.short_author(rev), 20))
1724
1585
out.append(self.date_string(rev))
1725
1586
if len(rev.parent_ids) > 1:
1726
1587
out.append('[merge]')
1785
1645
return self.get(name)(*args, **kwargs)
1787
1647
def get_default(self, branch):
1788
c = branch.get_config_stack()
1789
return self.get(c.get('log_format'))
1648
return self.get(branch.get_config().log_format())
1792
1651
log_formatter_registry = LogFormatterRegistry()
1795
1654
log_formatter_registry.register('short', ShortLogFormatter,
1796
'Moderately short log format.')
1655
'Moderately short log format')
1797
1656
log_formatter_registry.register('long', LongLogFormatter,
1798
'Detailed log format.')
1657
'Detailed log format')
1799
1658
log_formatter_registry.register('line', LineLogFormatter,
1800
'Log format with one line per revision.')
1659
'Log format with one line per revision')
1801
1660
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1802
'Format used by GNU ChangeLog files.')
1661
'Format used by GNU ChangeLog files')
1805
1664
def register_formatter(name, formatter):
1816
1675
return log_formatter_registry.make_formatter(name, *args, **kwargs)
1817
1676
except KeyError:
1818
raise errors.BzrCommandError(gettext("unknown log formatter: %r") % name)
1821
def author_list_all(rev):
1822
return rev.get_apparent_authors()[:]
1825
def author_list_first(rev):
1826
lst = rev.get_apparent_authors()
1833
def author_list_committer(rev):
1834
return [rev.committer]
1837
author_list_registry = registry.Registry()
1839
author_list_registry.register('all', author_list_all,
1842
author_list_registry.register('first', author_list_first,
1845
author_list_registry.register('committer', author_list_committer,
1677
raise errors.BzrCommandError("unknown log formatter: %r" % name)
1680
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1681
# deprecated; for compatibility
1682
lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
1683
lf.show(revno, rev, delta)
1849
1686
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
2007
1843
:param file_list: the list of paths given on the command line;
2008
1844
the first of these can be a branch location or a file path,
2009
1845
the remainder must be file paths
2010
:param add_cleanup: When the branch returned is read locked,
2011
an unlock call will be queued to the cleanup.
2012
1846
:return: (branch, info_list, start_rev_info, end_rev_info) where
2013
1847
info_list is a list of (relative_path, file_id, kind) tuples where
2014
1848
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2015
branch will be read-locked.
2017
from bzrlib.builtins import _get_revision_range
2018
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2020
add_cleanup(b.lock_read().unlock)
1850
from builtins import _get_revision_range, safe_relpath_files
1851
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2021
1852
# XXX: It's damn messy converting a list of paths to relative paths when
2022
1853
# those paths might be deleted ones, they might be on a case-insensitive
2023
1854
# filesystem and/or they might be in silly locations (like another branch).
2103
1934
properties_handler_registry = registry.Registry()
2105
# Use the properties handlers to print out bug information if available
2106
def _bugs_properties_handler(revision):
2107
if revision.properties.has_key('bugs'):
2108
bug_lines = revision.properties['bugs'].split('\n')
2109
bug_rows = [line.split(' ', 1) for line in bug_lines]
2110
fixed_bug_urls = [row[0] for row in bug_rows if
2111
len(row) > 1 and row[1] == 'fixed']
2114
return {ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls)):\
2115
' '.join(fixed_bug_urls)}
2118
properties_handler_registry.register('bugs_properties_handler',
2119
_bugs_properties_handler)
2122
1937
# adapters which revision ids to log are filtered. When log is called, the
2123
1938
# log_rev_iterator is adapted through each of these factory methods.
added
removed
bzrlib/log.py
