49
47
all the changes since the previous revision that touched hello.c.
50
from __future__ import absolute_import
53
from cStringIO import StringIO
54
from itertools import (
60
56
from warnings import (
64
from bzrlib.lazy_import import lazy_import
60
from .lazy_import import lazy_import
65
61
lazy_import(globals(), """
73
69
repository as _mod_repository,
74
70
revision as _mod_revision,
74
from breezy.i18n import gettext, ngettext
84
from bzrlib.osutils import (
81
from .osutils import (
86
83
format_date_with_offset_in_original_timezone,
84
get_diff_header_encoding,
87
85
get_terminal_encoding,
91
from bzrlib.symbol_versioning import (
88
from breezy.sixish import (
111
for revision_id in branch.revision_history():
109
graph = branch.repository.get_graph()
110
history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
111
[_mod_revision.NULL_REVISION]))
112
for revision_id in reversed(history):
112
113
this_inv = branch.repository.get_inventory(revision_id)
113
if file_id in this_inv:
114
if this_inv.has_id(file_id):
114
115
this_ie = this_inv[file_id]
115
116
this_path = this_inv.id2path(file_id)
214
210
Logger(branch, rqst).show(lf)
217
# Note: This needs to be kept this in sync with the defaults in
213
# Note: This needs to be kept in sync with the defaults in
218
214
# make_log_request_dict() below
219
215
_DEFAULT_REQUEST_PARAMS = {
220
216
'direction': 'reverse',
222
218
'generate_tags': True,
223
219
'exclude_common_ancestry': False,
224
220
'_match_using_deltas': True,
228
224
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
225
start_revision=None, end_revision=None, limit=None,
230
message_search=None, levels=1, generate_tags=True,
226
message_search=None, levels=None, generate_tags=True,
232
228
diff_type=None, _match_using_deltas=True,
233
exclude_common_ancestry=False,
229
exclude_common_ancestry=False, match=None,
230
signature=False, omit_merges=False,
235
232
"""Convenience function for making a logging request dictionary.
257
254
matching commit messages
259
256
:param levels: the number of levels of revisions to
260
generate; 1 for just the mainline; 0 for all levels.
257
generate; 1 for just the mainline; 0 for all levels, or None for
262
260
:param generate_tags: If True, include tags for matched revisions.
264
262
:param delta_type: Either 'full', 'partial' or None.
265
263
'full' means generate the complete delta - adds/deletes/modifies/etc;
266
264
'partial' means filter the delta using specific_fileids;
274
272
:param _match_using_deltas: a private parameter controlling the
275
273
algorithm used for matching specific_fileids. This parameter
276
may be removed in the future so bzrlib client code should NOT
274
may be removed in the future so breezy client code should NOT
279
277
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
278
range operator or as a graph difference.
280
:param signature: show digital signature information
282
:param match: Dictionary of list of search strings to use when filtering
283
revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
284
the empty string to match any of the preceding properties.
286
:param omit_merges: If True, commits with more than one parent are
290
# Take care of old style message_search parameter
293
if 'message' in match:
294
match['message'].append(message_search)
296
match['message'] = [message_search]
298
match={ 'message': [message_search] }
283
300
'direction': direction,
284
301
'specific_fileids': specific_fileids,
285
302
'start_revision': start_revision,
286
303
'end_revision': end_revision,
288
'message_search': message_search,
289
305
'levels': levels,
290
306
'generate_tags': generate_tags,
291
307
'delta_type': delta_type,
292
308
'diff_type': diff_type,
293
309
'exclude_common_ancestry': exclude_common_ancestry,
310
'signature': signature,
312
'omit_merges': omit_merges,
294
313
# Add 'private' attributes for features that may be deprecated
295
314
'_match_using_deltas': _match_using_deltas,
299
318
def _apply_log_request_defaults(rqst):
300
319
"""Apply default values to a request dictionary."""
301
result = _DEFAULT_REQUEST_PARAMS
320
result = _DEFAULT_REQUEST_PARAMS.copy()
303
322
result.update(rqst)
326
def format_signature_validity(rev_id, repo):
327
"""get the signature validity
329
:param rev_id: revision id to validate
330
:param repo: repository of revision
331
:return: human readable string to print to log
333
from breezy import gpg
335
gpg_strategy = gpg.GPGStrategy(None)
336
result = repo.verify_revision_signature(rev_id, gpg_strategy)
337
if result[0] == gpg.SIGNATURE_VALID:
338
return u"valid signature from {0}".format(result[1])
339
if result[0] == gpg.SIGNATURE_KEY_MISSING:
340
return "unknown key {0}".format(result[1])
341
if result[0] == gpg.SIGNATURE_NOT_VALID:
342
return "invalid signature!"
343
if result[0] == gpg.SIGNATURE_NOT_SIGNED:
344
return "no signature"
307
347
class LogGenerator(object):
308
348
"""A generator of log revisions."""
354
394
# Tweak the LogRequest based on what the LogFormatter can handle.
355
395
# (There's no point generating stuff if the formatter can't display it.)
357
rqst['levels'] = lf.get_levels()
397
if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
398
# user didn't specify levels, use whatever the LF can handle:
399
rqst['levels'] = lf.get_levels()
358
401
if not getattr(lf, 'supports_tags', False):
359
402
rqst['generate_tags'] = False
360
403
if not getattr(lf, 'supports_delta', False):
361
404
rqst['delta_type'] = None
362
405
if not getattr(lf, 'supports_diff', False):
363
406
rqst['diff_type'] = None
407
if not getattr(lf, 'supports_signatures', False):
408
rqst['signature'] = False
365
410
# Find and print the interesting revisions
366
411
generator = self._generator_factory(self.branch, rqst)
367
for lr in generator.iter_log_revisions():
413
for lr in generator.iter_log_revisions():
415
except errors.GhostRevisionUnusableHere:
416
raise errors.BzrCommandError(
417
gettext('Further revision history missing.'))
371
420
def _generator_factory(self, branch, rqst):
372
421
"""Make the LogGenerator object to use.
374
423
Subclasses may wish to override this.
376
425
return _DefaultLogGenerator(branch, rqst)
407
458
# 0 levels means show everything; merge_depth counts from 0
408
459
if levels != 0 and merge_depth >= levels:
461
if omit_merges and len(rev.parent_ids) > 1:
464
raise errors.GhostRevisionUnusableHere(rev_id)
410
465
if diff_type is None:
413
468
diff = self._format_diff(rev, rev_id, diff_type)
470
signature = format_signature_validity(rev_id,
471
self.branch.repository)
414
474
yield LogRevision(rev, revno, merge_depth, delta,
415
self.rev_tag_dict.get(rev_id), diff)
475
self.rev_tag_dict.get(rev_id), diff, signature)
418
478
if log_count >= limit:
473
534
# Apply the other filters
474
535
return make_log_rev_iterator(self.branch, view_revisions,
475
rqst.get('delta_type'), rqst.get('message_search'),
536
rqst.get('delta_type'), rqst.get('match'),
476
537
file_ids=rqst.get('specific_fileids'),
477
538
direction=rqst.get('direction'))
491
552
rqst.get('specific_fileids')[0], view_revisions,
492
553
include_merges=rqst.get('levels') != 1)
493
554
return make_log_rev_iterator(self.branch, view_revisions,
494
rqst.get('delta_type'), rqst.get('message_search'))
555
rqst.get('delta_type'), rqst.get('match'))
497
558
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
566
a list of the same tuples.
507
568
if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
569
raise errors.BzrCommandError(gettext(
570
'--exclude-common-ancestry requires two different revisions'))
510
571
if direction not in ('reverse', 'forward'):
511
raise ValueError('invalid direction %r' % direction)
572
raise ValueError(gettext('invalid direction %r') % direction)
512
573
br_revno, br_rev_id = branch.last_revision_info()
513
574
if br_revno == 0:
517
578
and (not generate_merge_revisions
518
579
or not _has_merges(branch, end_rev_id))):
519
580
# If a single revision is requested, check we can handle it
520
iter_revs = _generate_one_revision(branch, end_rev_id, br_rev_id,
522
elif not generate_merge_revisions:
523
# If we only want to see linear revisions, we can iterate ...
524
iter_revs = _generate_flat_revisions(branch, start_rev_id, end_rev_id,
526
if direction == 'forward':
527
iter_revs = reversed(iter_revs)
529
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
530
direction, delayed_graph_generation,
531
exclude_common_ancestry)
532
if direction == 'forward':
533
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
581
return _generate_one_revision(branch, end_rev_id, br_rev_id,
583
if not generate_merge_revisions:
585
# If we only want to see linear revisions, we can iterate ...
586
iter_revs = _linear_view_revisions(
587
branch, start_rev_id, end_rev_id,
588
exclude_common_ancestry=exclude_common_ancestry)
589
# If a start limit was given and it's not obviously an
590
# ancestor of the end limit, check it before outputting anything
591
if (direction == 'forward'
592
or (start_rev_id and not _is_obvious_ancestor(
593
branch, start_rev_id, end_rev_id))):
594
iter_revs = list(iter_revs)
595
if direction == 'forward':
596
iter_revs = reversed(iter_revs)
598
except _StartNotLinearAncestor:
599
# Switch to the slower implementation that may be able to find a
600
# non-obvious ancestor out of the left-hand history.
602
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
603
direction, delayed_graph_generation,
604
exclude_common_ancestry)
605
if direction == 'forward':
606
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
540
613
return [(br_rev_id, br_revno, 0)]
542
revno = branch.revision_id_to_dotted_revno(rev_id)
543
revno_str = '.'.join(str(n) for n in revno)
615
revno_str = _compute_revno_str(branch, rev_id)
544
616
return [(rev_id, revno_str, 0)]
547
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction):
548
result = _linear_view_revisions(branch, start_rev_id, end_rev_id)
549
# If a start limit was given and it's not obviously an
550
# ancestor of the end limit, check it before outputting anything
551
if direction == 'forward' or (start_rev_id
552
and not _is_obvious_ancestor(branch, start_rev_id, end_rev_id)):
554
result = list(result)
555
except _StartNotLinearAncestor:
556
raise errors.BzrCommandError('Start revision not found in'
557
' left-hand history of end revision.')
561
619
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
620
delayed_graph_generation,
563
621
exclude_common_ancestry=False):
572
630
if delayed_graph_generation:
574
632
for rev_id, revno, depth in _linear_view_revisions(
575
branch, start_rev_id, end_rev_id):
633
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
576
634
if _has_merges(branch, rev_id):
577
635
# The end_rev_id can be nested down somewhere. We need an
578
636
# explicit ancestry check. There is an ambiguity here as we
599
657
except _StartNotLinearAncestor:
600
658
# A merge was never detected so the lower revision limit can't
601
659
# be nested down somewhere
602
raise errors.BzrCommandError('Start revision not found in'
603
' history of end revision.')
660
raise errors.BzrCommandError(gettext('Start revision not found in'
661
' history of end revision.'))
605
663
# We exit the loop above because we encounter a revision with merges, from
606
664
# this revision, we need to switch to _graph_view_revisions.
610
668
# shown naturally, i.e. just like it is for linear logging. We can easily
611
669
# make forward the exact opposite display, but showing the merge revisions
612
670
# indented at the end seems slightly nicer in that case.
613
view_revisions = chain(iter(initial_revisions),
671
view_revisions = itertools.chain(iter(initial_revisions),
614
672
_graph_view_revisions(branch, start_rev_id, end_rev_id,
615
673
rebase_initial_depths=(direction == 'reverse'),
616
674
exclude_common_ancestry=exclude_common_ancestry))
623
681
return len(parents) > 1
684
def _compute_revno_str(branch, rev_id):
685
"""Compute the revno string from a rev_id.
687
:return: The revno string, or None if the revision is not in the supplied
691
revno = branch.revision_id_to_dotted_revno(rev_id)
692
except errors.NoSuchRevision:
693
# The revision must be outside of this branch
696
return '.'.join(str(n) for n in revno)
626
699
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
700
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
628
701
if start_rev_id and end_rev_id:
629
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
630
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
703
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
704
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
705
except errors.NoSuchRevision:
706
# one or both is not in the branch; not obvious
631
708
if len(start_dotted) == 1 and len(end_dotted) == 1:
632
709
# both on mainline
633
710
return start_dotted[0] <= end_dotted[0]
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
723
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
724
exclude_common_ancestry=False):
647
725
"""Calculate a sequence of revisions to view, newest to oldest.
649
727
:param start_rev_id: the lower revision-id
650
728
:param end_rev_id: the upper revision-id
729
:param exclude_common_ancestry: Whether the start_rev_id should be part of
730
the iterated revisions.
651
731
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
732
dotted_revno will be None for ghosts
652
733
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
is not found walking the left-hand history
734
is not found walking the left-hand history
655
736
br_revno, br_rev_id = branch.last_revision_info()
656
737
repo = branch.repository
738
graph = repo.get_graph()
657
739
if start_rev_id is None and end_rev_id is None:
658
740
cur_revno = br_revno
659
for revision_id in repo.iter_reverse_revision_history(br_rev_id):
660
yield revision_id, str(cur_revno), 0
741
graph_iter = graph.iter_lefthand_ancestry(br_rev_id,
742
(_mod_revision.NULL_REVISION,))
745
revision_id = next(graph_iter)
746
except errors.RevisionNotPresent as e:
748
yield e.revision_id, None, None
751
yield revision_id, str(cur_revno), 0
663
754
if end_rev_id is None:
664
755
end_rev_id = br_rev_id
665
756
found_start = start_rev_id is None
666
for revision_id in repo.iter_reverse_revision_history(end_rev_id):
667
revno = branch.revision_id_to_dotted_revno(revision_id)
668
revno_str = '.'.join(str(n) for n in revno)
669
if not found_start and revision_id == start_rev_id:
670
yield revision_id, revno_str, 0
757
graph_iter = graph.iter_lefthand_ancestry(end_rev_id,
758
(_mod_revision.NULL_REVISION,))
761
revision_id = next(graph_iter)
762
except StopIteration:
764
except errors.RevisionNotPresent as e:
766
yield e.revision_id, None, None
674
yield revision_id, revno_str, 0
677
raise _StartNotLinearAncestor()
769
revno_str = _compute_revno_str(branch, revision_id)
770
if not found_start and revision_id == start_rev_id:
771
if not exclude_common_ancestry:
772
yield revision_id, revno_str, 0
776
yield revision_id, revno_str, 0
778
raise _StartNotLinearAncestor()
680
781
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
721
822
yield rev_id, '.'.join(map(str, revno)), merge_depth
724
@deprecated_function(deprecated_in((2, 2, 0)))
725
def calculate_view_revisions(branch, start_revision, end_revision, direction,
726
specific_fileid, generate_merge_revisions):
727
"""Calculate the revisions to view.
729
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
730
a list of the same tuples.
732
start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
734
view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
735
direction, generate_merge_revisions or specific_fileid))
737
view_revisions = _filter_revisions_touching_file_id(branch,
738
specific_fileid, view_revisions,
739
include_merges=generate_merge_revisions)
740
return _rebase_merge_depth(view_revisions)
743
825
def _rebase_merge_depth(view_revisions):
744
826
"""Adjust depths upwards so the top level is 0."""
745
827
# If either the first or last revision have a merge_depth of 0, we're done
768
850
# Convert view_revisions into (view, None, None) groups to fit with
769
851
# the standard interface here.
770
if type(view_revisions) == list:
852
if isinstance(view_revisions, list):
771
853
# A single batch conversion is faster than many incremental ones.
772
854
# As we have all the data, do a batch conversion.
773
855
nones = [None] * len(view_revisions)
774
log_rev_iterator = iter([zip(view_revisions, nones, nones)])
856
log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
777
859
for view in view_revisions:
789
871
return log_rev_iterator
792
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
874
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
875
"""Create a filtered iterator of log_rev_iterator matching on a regex.
795
877
:param branch: The branch being logged.
796
878
:param generate_delta: Whether to generate a delta for each revision.
797
:param search: A user text search string.
879
:param match: A dictionary with properties as keys and lists of strings
880
as values. To match, a revision may match any of the supplied strings
881
within a single property but must match at least one string for each
798
883
:param log_rev_iterator: An input iterator containing all revisions that
799
884
could be displayed, in lists.
800
885
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
804
889
return log_rev_iterator
805
searchRE = re_compile_checked(search, re.IGNORECASE,
806
'log message filter')
807
return _filter_message_re(searchRE, log_rev_iterator)
810
def _filter_message_re(searchRE, log_rev_iterator):
890
searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
891
for k, v in match.items()]
892
return _filter_re(searchRE, log_rev_iterator)
895
def _filter_re(searchRE, log_rev_iterator):
811
896
for revs in log_rev_iterator:
813
for (rev_id, revno, merge_depth), rev, delta in revs:
814
if searchRE.search(rev.message):
815
new_revs.append(((rev_id, revno, merge_depth), rev, delta))
897
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
901
def _match_filter(searchRE, rev):
903
'message': (rev.message,),
904
'committer': (rev.committer,),
905
'author': (rev.get_apparent_authors()),
906
'bugs': list(rev.iter_bugs())
908
strings[''] = [item for inner_list in strings.values()
909
for item in inner_list]
910
for (k,v) in searchRE:
911
if k in strings and not _match_any_filter(strings[k], v):
915
def _match_any_filter(strings, res):
916
return any(re.search(s) for re in res for s in strings)
819
918
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
919
fileids=None, direction='reverse'):
866
965
if delta_type == 'full' and not check_fileids:
867
966
deltas = repository.get_deltas_for_revisions(revisions)
868
for rev, delta in izip(revs, deltas):
967
for rev, delta in zip(revs, deltas):
869
968
new_revs.append((rev[0], rev[1], delta))
871
970
deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
872
for rev, delta in izip(revs, deltas):
971
for rev, delta in zip(revs, deltas):
873
972
if check_fileids:
874
973
if delta is None or not delta.has_changed():
923
1022
for revs in log_rev_iterator:
924
1023
# r = revision_id, n = revno, d = merge depth
925
1024
revision_ids = [view[0] for view, _, _ in revs]
926
revisions = repository.get_revisions(revision_ids)
927
revs = [(rev[0], revision, rev[2]) for rev, revision in
928
izip(revs, revisions)]
1025
revisions = dict(repository.iter_revisions(revision_ids))
1026
yield [(rev[0], revisions[rev[0][0]], rev[2]) for rev in revs]
932
1029
def _make_batch_filter(branch, generate_delta, search, log_rev_iterator):
995
1091
if branch_revno != 0:
996
1092
if (start_rev_id == _mod_revision.NULL_REVISION
997
1093
or end_rev_id == _mod_revision.NULL_REVISION):
998
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1094
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
999
1095
if start_revno > end_revno:
1000
raise errors.BzrCommandError("Start revision must be older than "
1001
"the end revision.")
1096
raise errors.BzrCommandError(gettext("Start revision must be "
1097
"older than the end revision."))
1002
1098
return (start_rev_id, end_rev_id)
1054
1150
if ((start_rev_id == _mod_revision.NULL_REVISION)
1055
1151
or (end_rev_id == _mod_revision.NULL_REVISION)):
1056
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1152
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1057
1153
if start_revno > end_revno:
1058
raise errors.BzrCommandError("Start revision must be older than "
1059
"the end revision.")
1154
raise errors.BzrCommandError(gettext("Start revision must be older "
1155
"than the end revision."))
1061
1157
if end_revno < start_revno:
1062
1158
return None, None, None, None
1063
1159
cur_revno = branch_revno
1065
1161
mainline_revs = []
1066
for revision_id in branch.repository.iter_reverse_revision_history(
1067
branch_last_revision):
1162
graph = branch.repository.get_graph()
1163
for revision_id in graph.iter_lefthand_ancestry(
1164
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1068
1165
if cur_revno < start_revno:
1069
1166
# We have gone far enough, but we always add 1 more revision
1070
1167
rev_nos[revision_id] = cur_revno
1084
1181
return mainline_revs, rev_nos, start_rev_id, end_rev_id
1087
@deprecated_function(deprecated_in((2, 2, 0)))
1088
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1089
"""Filter view_revisions based on revision ranges.
1091
:param view_revisions: A list of (revision_id, dotted_revno, merge_depth)
1092
tuples to be filtered.
1094
:param start_rev_id: If not NONE specifies the first revision to be logged.
1095
If NONE then all revisions up to the end_rev_id are logged.
1097
:param end_rev_id: If not NONE specifies the last revision to be logged.
1098
If NONE then all revisions up to the end of the log are logged.
1100
:return: The filtered view_revisions.
1102
if start_rev_id or end_rev_id:
1103
revision_ids = [r for r, n, d in view_revisions]
1105
start_index = revision_ids.index(start_rev_id)
1108
if start_rev_id == end_rev_id:
1109
end_index = start_index
1112
end_index = revision_ids.index(end_rev_id)
1114
end_index = len(view_revisions) - 1
1115
# To include the revisions merged into the last revision,
1116
# extend end_rev_id down to, but not including, the next rev
1117
# with the same or lesser merge_depth
1118
end_merge_depth = view_revisions[end_index][2]
1120
for index in xrange(end_index+1, len(view_revisions)+1):
1121
if view_revisions[index][2] <= end_merge_depth:
1122
end_index = index - 1
1125
# if the search falls off the end then log to the end as well
1126
end_index = len(view_revisions) - 1
1127
view_revisions = view_revisions[start_index:end_index+1]
1128
return view_revisions
1131
1184
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
1185
include_merges=True):
1133
1186
r"""Return the list of revision ids which touch a given file id.
1177
1233
# indexing layer. We might consider passing in hints as to the known
1178
1234
# access pattern (sparse/clustered, high success rate/low success
1179
1235
# rate). This particular access is clustered with a low success rate.
1180
get_parent_map = branch.repository.texts.get_parent_map
1181
1236
modified_text_revisions = set()
1182
1237
chunk_size = 1000
1183
for start in xrange(0, len(text_keys), chunk_size):
1238
for start in range(0, len(text_keys), chunk_size):
1184
1239
next_keys = text_keys[start:start + chunk_size]
1185
1240
# Only keep the revision_id portion of the key
1186
1241
modified_text_revisions.update(
1213
@deprecated_function(deprecated_in((2, 2, 0)))
1214
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1215
include_merges=True):
1216
"""Produce an iterator of revisions to show
1217
:return: an iterator of (revision_id, revno, merge_depth)
1218
(if there is no revno for a revision, None is supplied)
1220
if not include_merges:
1221
revision_ids = mainline_revs[1:]
1222
if direction == 'reverse':
1223
revision_ids.reverse()
1224
for revision_id in revision_ids:
1225
yield revision_id, str(rev_nos[revision_id]), 0
1227
graph = branch.repository.get_graph()
1228
# This asks for all mainline revisions, which means we only have to spider
1229
# sideways, rather than depth history. That said, its still size-of-history
1230
# and should be addressed.
1231
# mainline_revisions always includes an extra revision at the beginning, so
1233
parent_map = dict(((key, value) for key, value in
1234
graph.iter_ancestry(mainline_revs[1:]) if value is not None))
1235
# filter out ghosts; merge_sort errors on ghosts.
1236
rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
1237
merge_sorted_revisions = tsort.merge_sort(
1241
generate_revno=True)
1243
if direction == 'forward':
1244
# forward means oldest first.
1245
merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
1246
elif direction != 'reverse':
1247
raise ValueError('invalid direction %r' % direction)
1249
for (sequence, rev_id, merge_depth, revno, end_of_merge
1250
) in merge_sorted_revisions:
1251
yield rev_id, '.'.join(map(str, revno)), merge_depth
1254
1268
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1269
"""Reverse revisions by depth.
1312
1330
to indicate which LogRevision attributes it supports:
1314
1332
- supports_delta must be True if this log formatter supports delta.
1315
Otherwise the delta attribute may not be populated. The 'delta_format'
1316
attribute describes whether the 'short_status' format (1) or the long
1317
one (2) should be used.
1333
Otherwise the delta attribute may not be populated. The 'delta_format'
1334
attribute describes whether the 'short_status' format (1) or the long
1335
one (2) should be used.
1319
1337
- supports_merge_revisions must be True if this log formatter supports
1320
merge revisions. If not, then only mainline revisions will be passed
1338
merge revisions. If not, then only mainline revisions will be passed
1323
1341
- preferred_levels is the number of levels this formatter defaults to.
1324
The default value is zero meaning display all levels.
1325
This value is only relevant if supports_merge_revisions is True.
1342
The default value is zero meaning display all levels.
1343
This value is only relevant if supports_merge_revisions is True.
1327
1345
- supports_tags must be True if this log formatter supports tags.
1328
Otherwise the tags attribute may not be populated.
1346
Otherwise the tags attribute may not be populated.
1330
1348
- supports_diff must be True if this log formatter supports diffs.
1331
Otherwise the diff attribute may not be populated.
1349
Otherwise the diff attribute may not be populated.
1351
- supports_signatures must be True if this log formatter supports GPG
1333
1354
Plugins can register functions to show custom revision properties using
1334
1355
the properties_handler_registry. The registered function
1335
must respect the following interface description:
1356
must respect the following interface description::
1336
1358
def my_show_properties(properties_dict):
1337
1359
# code that returns a dict {'name':'value'} of the properties
1342
1364
def __init__(self, to_file, show_ids=False, show_timezone='original',
1343
1365
delta_format=None, levels=None, show_advice=False,
1344
to_exact_file=None):
1366
to_exact_file=None, author_list_handler=None):
1345
1367
"""Create a LogFormatter.
1347
1369
:param to_file: the file to output to
1348
:param to_exact_file: if set, gives an output stream to which
1370
:param to_exact_file: if set, gives an output stream to which
1349
1371
non-Unicode diffs are written.
1350
1372
:param show_ids: if True, revision-ids are to be displayed
1351
1373
:param show_timezone: the timezone to use
1414
1439
def short_author(self, rev):
1415
name, address = config.parse_username(rev.get_apparent_authors()[0])
1440
return self.authors(rev, 'first', short=True, sep=', ')
1442
def authors(self, rev, who, short=False, sep=None):
1443
"""Generate list of authors, taking --authors option into account.
1445
The caller has to specify the name of a author list handler,
1446
as provided by the author list registry, using the ``who``
1447
argument. That name only sets a default, though: when the
1448
user selected a different author list generation using the
1449
``--authors`` command line switch, as represented by the
1450
``author_list_handler`` constructor argument, that value takes
1453
:param rev: The revision for which to generate the list of authors.
1454
:param who: Name of the default handler.
1455
:param short: Whether to shorten names to either name or address.
1456
:param sep: What separator to use for automatic concatenation.
1458
if self._author_list_handler is not None:
1459
# The user did specify --authors, which overrides the default
1460
author_list_handler = self._author_list_handler
1462
# The user didn't specify --authors, so we use the caller's default
1463
author_list_handler = author_list_registry.get(who)
1464
names = author_list_handler(rev)
1466
for i in range(len(names)):
1467
name, address = config.parse_username(names[i])
1473
names = sep.join(names)
1420
1476
def merge_marker(self, revision):
1421
1477
"""Get the merge marker to include in the output or '' if none."""
1516
1573
self.merge_marker(revision)))
1517
1574
if revision.tags:
1518
1575
lines.append('tags: %s' % (', '.join(revision.tags)))
1576
if self.show_ids or revision.revno is None:
1520
1577
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1521
1579
for parent_id in revision.rev.parent_ids:
1522
1580
lines.append('parent: %s' % (parent_id,))
1523
1581
lines.extend(self.custom_properties(revision.rev))
1525
1583
committer = revision.rev.committer
1526
authors = revision.rev.get_apparent_authors()
1584
authors = self.authors(revision.rev, 'all')
1527
1585
if authors != [committer]:
1528
1586
lines.append('author: %s' % (", ".join(authors),))
1529
1587
lines.append('committer: %s' % (committer,))
1547
1608
to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1548
1609
if revision.delta is not None:
1549
1610
# Use the standard status output to display changes
1550
from bzrlib.delta import report_delta
1551
report_delta(to_file, revision.delta, short_status=False,
1611
from breezy.delta import report_delta
1612
report_delta(to_file, revision.delta, short_status=False,
1552
1613
show_ids=self.show_ids, indent=indent)
1553
1614
if revision.diff is not None:
1554
1615
to_file.write(indent + 'diff:\n')
1600
1661
if revision.tags:
1601
1662
tags = ' {%s}' % (', '.join(revision.tags))
1602
1663
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1603
revision.revno, self.short_author(revision.rev),
1664
revision.revno or "", self.short_author(revision.rev),
1604
1665
format_date(revision.rev.timestamp,
1605
1666
revision.rev.timezone or 0,
1606
1667
self.show_timezone, date_fmt="%Y-%m-%d",
1607
1668
show_offset=False),
1608
1669
tags, self.merge_marker(revision)))
1609
1670
self.show_properties(revision.rev, indent+offset)
1671
if self.show_ids or revision.revno is None:
1611
1672
to_file.write(indent + offset + 'revision-id:%s\n'
1612
1673
% (revision.rev.revision_id,))
1613
1674
if not revision.rev.message:
1620
1681
if revision.delta is not None:
1621
1682
# Use the standard status output to display changes
1622
from bzrlib.delta import report_delta
1623
report_delta(to_file, revision.delta,
1624
short_status=self.delta_format==1,
1683
from breezy.delta import report_delta
1684
report_delta(to_file, revision.delta,
1685
short_status=self.delta_format==1,
1625
1686
show_ids=self.show_ids, indent=indent + offset)
1626
1687
if revision.diff is not None:
1627
1688
self.show_diff(self.to_exact_file, revision.diff, ' ')
1667
1728
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1668
1729
"""Format log info into one string. Truncate tail of string
1669
:param revno: revision number or None.
1670
Revision numbers counts from 1.
1671
:param rev: revision object
1672
:param max_chars: maximum length of resulting string
1673
:param tags: list of tags or None
1674
:param prefix: string to prefix each line
1675
:return: formatted truncated string
1731
:param revno: revision number or None.
1732
Revision numbers counts from 1.
1733
:param rev: revision object
1734
:param max_chars: maximum length of resulting string
1735
:param tags: list of tags or None
1736
:param prefix: string to prefix each line
1737
:return: formatted truncated string
1679
1741
# show revno only when is not None
1680
1742
out.append("%s:" % revno)
1681
out.append(self.truncate(self.short_author(rev), 20))
1743
if max_chars is not None:
1744
out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
1746
out.append(self.short_author(rev))
1682
1747
out.append(self.date_string(rev))
1683
1748
if len(rev.parent_ids) > 1:
1684
1749
out.append('[merge]')
1742
1808
return self.get(name)(*args, **kwargs)
1744
1810
def get_default(self, branch):
1745
return self.get(branch.get_config().log_format())
1811
c = branch.get_config_stack()
1812
return self.get(c.get('log_format'))
1748
1815
log_formatter_registry = LogFormatterRegistry()
1751
1818
log_formatter_registry.register('short', ShortLogFormatter,
1752
'Moderately short log format')
1819
'Moderately short log format.')
1753
1820
log_formatter_registry.register('long', LongLogFormatter,
1754
'Detailed log format')
1821
'Detailed log format.')
1755
1822
log_formatter_registry.register('line', LineLogFormatter,
1756
'Log format with one line per revision')
1823
'Log format with one line per revision.')
1757
1824
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1758
'Format used by GNU ChangeLog files')
1825
'Format used by GNU ChangeLog files.')
1761
1828
def register_formatter(name, formatter):
1772
1839
return log_formatter_registry.make_formatter(name, *args, **kwargs)
1773
1840
except KeyError:
1774
raise errors.BzrCommandError("unknown log formatter: %r" % name)
1777
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1778
# deprecated; for compatibility
1779
lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
1780
lf.show(revno, rev, delta)
1841
raise errors.BzrCommandError(gettext("unknown log formatter: %r") % name)
1844
def author_list_all(rev):
1845
return rev.get_apparent_authors()[:]
1848
def author_list_first(rev):
1849
lst = rev.get_apparent_authors()
1856
def author_list_committer(rev):
1857
return [rev.committer]
1860
author_list_registry = registry.Registry()
1862
author_list_registry.register('all', author_list_all,
1865
author_list_registry.register('first', author_list_first,
1868
author_list_registry.register('committer', author_list_committer,
1783
1872
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1940
2029
:param file_list: the list of paths given on the command line;
1941
2030
the first of these can be a branch location or a file path,
1942
2031
the remainder must be file paths
2032
:param add_cleanup: When the branch returned is read locked,
2033
an unlock call will be queued to the cleanup.
1943
2034
:return: (branch, info_list, start_rev_info, end_rev_info) where
1944
2035
info_list is a list of (relative_path, file_id, kind) tuples where
1945
2036
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1946
2037
branch will be read-locked.
1948
from builtins import _get_revision_range, safe_relpath_files
1949
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2039
from breezy.builtins import _get_revision_range
2040
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2042
add_cleanup(b.lock_read().unlock)
1951
2043
# XXX: It's damn messy converting a list of paths to relative paths when
1952
2044
# those paths might be deleted ones, they might be on a case-insensitive
1953
2045
# filesystem and/or they might be in silly locations (like another branch).
2035
2127
# Use the properties handlers to print out bug information if available
2036
2128
def _bugs_properties_handler(revision):
2037
if revision.properties.has_key('bugs'):
2129
if 'bugs' in revision.properties:
2038
2130
bug_lines = revision.properties['bugs'].split('\n')
2039
2131
bug_rows = [line.split(' ', 1) for line in bug_lines]
2040
2132
fixed_bug_urls = [row[0] for row in bug_rows if
2041
2133
len(row) > 1 and row[1] == 'fixed']
2043
2135
if fixed_bug_urls:
2044
return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2136
return {ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls)):\
2137
' '.join(fixed_bug_urls)}
2047
2140
properties_handler_registry.register('bugs_properties_handler',