65
65
lazy_import(globals(), """
67
67
from bzrlib import (
73
73
repository as _mod_repository,
74
74
revision as _mod_revision,
78
from bzrlib.i18n import gettext, ngettext
81
81
from bzrlib import (
84
85
from bzrlib.osutils import (
86
87
format_date_with_offset_in_original_timezone,
88
get_diff_header_encoding,
87
89
get_terminal_encoding,
91
from bzrlib.symbol_versioning import (
97
94
def find_touching_revisions(branch, file_id):
111
for revision_id in branch.revision_history():
108
graph = branch.repository.get_graph()
109
history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
110
[_mod_revision.NULL_REVISION]))
111
for revision_id in reversed(history):
112
112
this_inv = branch.repository.get_inventory(revision_id)
113
if file_id in this_inv:
113
if this_inv.has_id(file_id):
114
114
this_ie = this_inv[file_id]
115
115
this_path = this_inv.id2path(file_id)
214
218
Logger(branch, rqst).show(lf)
217
# Note: This needs to be kept this in sync with the defaults in
221
# Note: This needs to be kept in sync with the defaults in
218
222
# make_log_request_dict() below
219
223
_DEFAULT_REQUEST_PARAMS = {
220
224
'direction': 'reverse',
222
226
'generate_tags': True,
223
227
'exclude_common_ancestry': False,
224
228
'_match_using_deltas': True,
228
232
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
233
start_revision=None, end_revision=None, limit=None,
230
message_search=None, levels=1, generate_tags=True,
234
message_search=None, levels=None, generate_tags=True,
232
236
diff_type=None, _match_using_deltas=True,
233
exclude_common_ancestry=False,
237
exclude_common_ancestry=False, match=None,
238
signature=False, omit_merges=False,
235
240
"""Convenience function for making a logging request dictionary.
257
262
matching commit messages
259
264
:param levels: the number of levels of revisions to
260
generate; 1 for just the mainline; 0 for all levels.
265
generate; 1 for just the mainline; 0 for all levels, or None for
262
268
:param generate_tags: If True, include tags for matched revisions.
264
270
:param delta_type: Either 'full', 'partial' or None.
265
271
'full' means generate the complete delta - adds/deletes/modifies/etc;
266
272
'partial' means filter the delta using specific_fileids;
279
285
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
286
range operator or as a graph difference.
288
:param signature: show digital signature information
290
:param match: Dictionary of list of search strings to use when filtering
291
revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
292
the empty string to match any of the preceding properties.
294
:param omit_merges: If True, commits with more than one parent are
298
# Take care of old style message_search parameter
301
if 'message' in match:
302
match['message'].append(message_search)
304
match['message'] = [message_search]
306
match={ 'message': [message_search] }
283
308
'direction': direction,
284
309
'specific_fileids': specific_fileids,
285
310
'start_revision': start_revision,
286
311
'end_revision': end_revision,
288
'message_search': message_search,
289
313
'levels': levels,
290
314
'generate_tags': generate_tags,
291
315
'delta_type': delta_type,
292
316
'diff_type': diff_type,
293
317
'exclude_common_ancestry': exclude_common_ancestry,
318
'signature': signature,
320
'omit_merges': omit_merges,
294
321
# Add 'private' attributes for features that may be deprecated
295
322
'_match_using_deltas': _match_using_deltas,
299
326
def _apply_log_request_defaults(rqst):
300
327
"""Apply default values to a request dictionary."""
301
result = _DEFAULT_REQUEST_PARAMS
328
result = _DEFAULT_REQUEST_PARAMS.copy()
303
330
result.update(rqst)
334
def format_signature_validity(rev_id, repo):
335
"""get the signature validity
337
:param rev_id: revision id to validate
338
:param repo: repository of revision
339
:return: human readable string to print to log
341
from bzrlib import gpg
343
gpg_strategy = gpg.GPGStrategy(None)
344
result = repo.verify_revision_signature(rev_id, gpg_strategy)
345
if result[0] == gpg.SIGNATURE_VALID:
346
return "valid signature from {0}".format(result[1])
347
if result[0] == gpg.SIGNATURE_KEY_MISSING:
348
return "unknown key {0}".format(result[1])
349
if result[0] == gpg.SIGNATURE_NOT_VALID:
350
return "invalid signature!"
351
if result[0] == gpg.SIGNATURE_NOT_SIGNED:
352
return "no signature"
307
355
class LogGenerator(object):
308
356
"""A generator of log revisions."""
354
402
# Tweak the LogRequest based on what the LogFormatter can handle.
355
403
# (There's no point generating stuff if the formatter can't display it.)
357
rqst['levels'] = lf.get_levels()
405
if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
406
# user didn't specify levels, use whatever the LF can handle:
407
rqst['levels'] = lf.get_levels()
358
409
if not getattr(lf, 'supports_tags', False):
359
410
rqst['generate_tags'] = False
360
411
if not getattr(lf, 'supports_delta', False):
361
412
rqst['delta_type'] = None
362
413
if not getattr(lf, 'supports_diff', False):
363
414
rqst['diff_type'] = None
415
if not getattr(lf, 'supports_signatures', False):
416
rqst['signature'] = False
365
418
# Find and print the interesting revisions
366
419
generator = self._generator_factory(self.branch, rqst)
407
462
# 0 levels means show everything; merge_depth counts from 0
408
463
if levels != 0 and merge_depth >= levels:
465
if omit_merges and len(rev.parent_ids) > 1:
410
467
if diff_type is None:
413
470
diff = self._format_diff(rev, rev_id, diff_type)
472
signature = format_signature_validity(rev_id,
473
self.branch.repository)
414
476
yield LogRevision(rev, revno, merge_depth, delta,
415
self.rev_tag_dict.get(rev_id), diff)
477
self.rev_tag_dict.get(rev_id), diff, signature)
418
480
if log_count >= limit:
473
536
# Apply the other filters
474
537
return make_log_rev_iterator(self.branch, view_revisions,
475
rqst.get('delta_type'), rqst.get('message_search'),
538
rqst.get('delta_type'), rqst.get('match'),
476
539
file_ids=rqst.get('specific_fileids'),
477
540
direction=rqst.get('direction'))
491
554
rqst.get('specific_fileids')[0], view_revisions,
492
555
include_merges=rqst.get('levels') != 1)
493
556
return make_log_rev_iterator(self.branch, view_revisions,
494
rqst.get('delta_type'), rqst.get('message_search'))
557
rqst.get('delta_type'), rqst.get('match'))
497
560
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
568
a list of the same tuples.
507
570
if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
571
raise errors.BzrCommandError(gettext(
572
'--exclude-common-ancestry requires two different revisions'))
510
573
if direction not in ('reverse', 'forward'):
511
raise ValueError('invalid direction %r' % direction)
574
raise ValueError(gettext('invalid direction %r') % direction)
512
575
br_revno, br_rev_id = branch.last_revision_info()
513
576
if br_revno == 0:
517
580
and (not generate_merge_revisions
518
581
or not _has_merges(branch, end_rev_id))):
519
582
# 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)))
583
return _generate_one_revision(branch, end_rev_id, br_rev_id,
585
if not generate_merge_revisions:
587
# If we only want to see linear revisions, we can iterate ...
588
iter_revs = _linear_view_revisions(
589
branch, start_rev_id, end_rev_id,
590
exclude_common_ancestry=exclude_common_ancestry)
591
# If a start limit was given and it's not obviously an
592
# ancestor of the end limit, check it before outputting anything
593
if (direction == 'forward'
594
or (start_rev_id and not _is_obvious_ancestor(
595
branch, start_rev_id, end_rev_id))):
596
iter_revs = list(iter_revs)
597
if direction == 'forward':
598
iter_revs = reversed(iter_revs)
600
except _StartNotLinearAncestor:
601
# Switch to the slower implementation that may be able to find a
602
# non-obvious ancestor out of the left-hand history.
604
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
605
direction, delayed_graph_generation,
606
exclude_common_ancestry)
607
if direction == 'forward':
608
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
540
615
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)
617
revno_str = _compute_revno_str(branch, rev_id)
544
618
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
621
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
622
delayed_graph_generation,
563
623
exclude_common_ancestry=False):
572
632
if delayed_graph_generation:
574
634
for rev_id, revno, depth in _linear_view_revisions(
575
branch, start_rev_id, end_rev_id):
635
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
576
636
if _has_merges(branch, rev_id):
577
637
# The end_rev_id can be nested down somewhere. We need an
578
638
# explicit ancestry check. There is an ambiguity here as we
599
659
except _StartNotLinearAncestor:
600
660
# A merge was never detected so the lower revision limit can't
601
661
# be nested down somewhere
602
raise errors.BzrCommandError('Start revision not found in'
603
' history of end revision.')
662
raise errors.BzrCommandError(gettext('Start revision not found in'
663
' history of end revision.'))
605
665
# We exit the loop above because we encounter a revision with merges, from
606
666
# this revision, we need to switch to _graph_view_revisions.
623
683
return len(parents) > 1
686
def _compute_revno_str(branch, rev_id):
687
"""Compute the revno string from a rev_id.
689
:return: The revno string, or None if the revision is not in the supplied
693
revno = branch.revision_id_to_dotted_revno(rev_id)
694
except errors.NoSuchRevision:
695
# The revision must be outside of this branch
698
return '.'.join(str(n) for n in revno)
626
701
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
702
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
628
703
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)
705
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
706
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
707
except errors.NoSuchRevision:
708
# one or both is not in the branch; not obvious
631
710
if len(start_dotted) == 1 and len(end_dotted) == 1:
632
711
# both on mainline
633
712
return start_dotted[0] <= end_dotted[0]
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
725
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
726
exclude_common_ancestry=False):
647
727
"""Calculate a sequence of revisions to view, newest to oldest.
649
729
:param start_rev_id: the lower revision-id
650
730
:param end_rev_id: the upper revision-id
731
:param exclude_common_ancestry: Whether the start_rev_id should be part of
732
the iterated revisions.
651
733
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
652
734
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
is not found walking the left-hand history
735
is not found walking the left-hand history
655
737
br_revno, br_rev_id = branch.last_revision_info()
656
738
repo = branch.repository
739
graph = repo.get_graph()
657
740
if start_rev_id is None and end_rev_id is None:
658
741
cur_revno = br_revno
659
for revision_id in repo.iter_reverse_revision_history(br_rev_id):
742
for revision_id in graph.iter_lefthand_ancestry(br_rev_id,
743
(_mod_revision.NULL_REVISION,)):
660
744
yield revision_id, str(cur_revno), 0
663
747
if end_rev_id is None:
664
748
end_rev_id = br_rev_id
665
749
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)
750
for revision_id in graph.iter_lefthand_ancestry(end_rev_id,
751
(_mod_revision.NULL_REVISION,)):
752
revno_str = _compute_revno_str(branch, revision_id)
669
753
if not found_start and revision_id == start_rev_id:
670
yield revision_id, revno_str, 0
754
if not exclude_common_ancestry:
755
yield revision_id, revno_str, 0
671
756
found_start = True
721
806
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
809
def _rebase_merge_depth(view_revisions):
744
810
"""Adjust depths upwards so the top level is 0."""
745
811
# If either the first or last revision have a merge_depth of 0, we're done
789
855
return log_rev_iterator
792
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
858
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
859
"""Create a filtered iterator of log_rev_iterator matching on a regex.
795
861
:param branch: The branch being logged.
796
862
:param generate_delta: Whether to generate a delta for each revision.
797
:param search: A user text search string.
863
:param match: A dictionary with properties as keys and lists of strings
864
as values. To match, a revision may match any of the supplied strings
865
within a single property but must match at least one string for each
798
867
:param log_rev_iterator: An input iterator containing all revisions that
799
868
could be displayed, in lists.
800
869
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
804
873
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):
874
searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
875
for (k,v) in match.iteritems()]
876
return _filter_re(searchRE, log_rev_iterator)
879
def _filter_re(searchRE, log_rev_iterator):
811
880
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))
881
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
885
def _match_filter(searchRE, rev):
887
'message': (rev.message,),
888
'committer': (rev.committer,),
889
'author': (rev.get_apparent_authors()),
890
'bugs': list(rev.iter_bugs())
892
strings[''] = [item for inner_list in strings.itervalues()
893
for item in inner_list]
894
for (k,v) in searchRE:
895
if k in strings and not _match_any_filter(strings[k], v):
899
def _match_any_filter(strings, res):
900
return any([filter(None, map(re.search, strings)) for re in res])
819
902
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
903
fileids=None, direction='reverse'):
995
1077
if branch_revno != 0:
996
1078
if (start_rev_id == _mod_revision.NULL_REVISION
997
1079
or end_rev_id == _mod_revision.NULL_REVISION):
998
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1080
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
999
1081
if start_revno > end_revno:
1000
raise errors.BzrCommandError("Start revision must be older than "
1001
"the end revision.")
1082
raise errors.BzrCommandError(gettext("Start revision must be "
1083
"older than the end revision."))
1002
1084
return (start_rev_id, end_rev_id)
1054
1136
if ((start_rev_id == _mod_revision.NULL_REVISION)
1055
1137
or (end_rev_id == _mod_revision.NULL_REVISION)):
1056
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1138
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1057
1139
if start_revno > end_revno:
1058
raise errors.BzrCommandError("Start revision must be older than "
1059
"the end revision.")
1140
raise errors.BzrCommandError(gettext("Start revision must be older "
1141
"than the end revision."))
1061
1143
if end_revno < start_revno:
1062
1144
return None, None, None, None
1063
1145
cur_revno = branch_revno
1065
1147
mainline_revs = []
1066
for revision_id in branch.repository.iter_reverse_revision_history(
1067
branch_last_revision):
1148
graph = branch.repository.get_graph()
1149
for revision_id in graph.iter_lefthand_ancestry(
1150
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1068
1151
if cur_revno < start_revno:
1069
1152
# We have gone far enough, but we always add 1 more revision
1070
1153
rev_nos[revision_id] = cur_revno
1084
1167
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
1170
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
1171
include_merges=True):
1133
1172
r"""Return the list of revision ids which touch a given file id.
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
1254
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1255
"""Reverse revisions by depth.
1293
1293
def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
1294
tags=None, diff=None):
1294
tags=None, diff=None, signature=None):
1296
self.revno = str(revno)
1299
self.revno = str(revno)
1297
1300
self.merge_depth = merge_depth
1298
1301
self.delta = delta
1299
1302
self.tags = tags
1300
1303
self.diff = diff
1304
self.signature = signature
1303
1307
class LogFormatter(object):
1312
1316
to indicate which LogRevision attributes it supports:
1314
1318
- 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.
1319
Otherwise the delta attribute may not be populated. The 'delta_format'
1320
attribute describes whether the 'short_status' format (1) or the long
1321
one (2) should be used.
1319
1323
- supports_merge_revisions must be True if this log formatter supports
1320
merge revisions. If not, then only mainline revisions will be passed
1324
merge revisions. If not, then only mainline revisions will be passed
1323
1327
- 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.
1328
The default value is zero meaning display all levels.
1329
This value is only relevant if supports_merge_revisions is True.
1327
1331
- supports_tags must be True if this log formatter supports tags.
1328
Otherwise the tags attribute may not be populated.
1332
Otherwise the tags attribute may not be populated.
1330
1334
- supports_diff must be True if this log formatter supports diffs.
1331
Otherwise the diff attribute may not be populated.
1335
Otherwise the diff attribute may not be populated.
1337
- supports_signatures must be True if this log formatter supports GPG
1333
1340
Plugins can register functions to show custom revision properties using
1334
1341
the properties_handler_registry. The registered function
1335
must respect the following interface description:
1342
must respect the following interface description::
1336
1344
def my_show_properties(properties_dict):
1337
1345
# code that returns a dict {'name':'value'} of the properties
1342
1350
def __init__(self, to_file, show_ids=False, show_timezone='original',
1343
1351
delta_format=None, levels=None, show_advice=False,
1344
to_exact_file=None):
1352
to_exact_file=None, author_list_handler=None):
1345
1353
"""Create a LogFormatter.
1347
1355
:param to_file: the file to output to
1348
:param to_exact_file: if set, gives an output stream to which
1356
:param to_exact_file: if set, gives an output stream to which
1349
1357
non-Unicode diffs are written.
1350
1358
:param show_ids: if True, revision-ids are to be displayed
1351
1359
:param show_timezone: the timezone to use
1414
1425
def short_author(self, rev):
1415
name, address = config.parse_username(rev.get_apparent_authors()[0])
1426
return self.authors(rev, 'first', short=True, sep=', ')
1428
def authors(self, rev, who, short=False, sep=None):
1429
"""Generate list of authors, taking --authors option into account.
1431
The caller has to specify the name of a author list handler,
1432
as provided by the author list registry, using the ``who``
1433
argument. That name only sets a default, though: when the
1434
user selected a different author list generation using the
1435
``--authors`` command line switch, as represented by the
1436
``author_list_handler`` constructor argument, that value takes
1439
:param rev: The revision for which to generate the list of authors.
1440
:param who: Name of the default handler.
1441
:param short: Whether to shorten names to either name or address.
1442
:param sep: What separator to use for automatic concatenation.
1444
if self._author_list_handler is not None:
1445
# The user did specify --authors, which overrides the default
1446
author_list_handler = self._author_list_handler
1448
# The user didn't specify --authors, so we use the caller's default
1449
author_list_handler = author_list_registry.get(who)
1450
names = author_list_handler(rev)
1452
for i in range(len(names)):
1453
name, address = config.parse_username(names[i])
1459
names = sep.join(names)
1420
1462
def merge_marker(self, revision):
1421
1463
"""Get the merge marker to include in the output or '' if none."""
1516
1559
self.merge_marker(revision)))
1517
1560
if revision.tags:
1518
1561
lines.append('tags: %s' % (', '.join(revision.tags)))
1562
if self.show_ids or revision.revno is None:
1520
1563
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1521
1565
for parent_id in revision.rev.parent_ids:
1522
1566
lines.append('parent: %s' % (parent_id,))
1523
1567
lines.extend(self.custom_properties(revision.rev))
1525
1569
committer = revision.rev.committer
1526
authors = revision.rev.get_apparent_authors()
1570
authors = self.authors(revision.rev, 'all')
1527
1571
if authors != [committer]:
1528
1572
lines.append('author: %s' % (", ".join(authors),))
1529
1573
lines.append('committer: %s' % (committer,))
1548
1595
if revision.delta is not None:
1549
1596
# Use the standard status output to display changes
1550
1597
from bzrlib.delta import report_delta
1551
report_delta(to_file, revision.delta, short_status=False,
1598
report_delta(to_file, revision.delta, short_status=False,
1552
1599
show_ids=self.show_ids, indent=indent)
1553
1600
if revision.diff is not None:
1554
1601
to_file.write(indent + 'diff:\n')
1600
1647
if revision.tags:
1601
1648
tags = ' {%s}' % (', '.join(revision.tags))
1602
1649
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1603
revision.revno, self.short_author(revision.rev),
1650
revision.revno or "", self.short_author(revision.rev),
1604
1651
format_date(revision.rev.timestamp,
1605
1652
revision.rev.timezone or 0,
1606
1653
self.show_timezone, date_fmt="%Y-%m-%d",
1607
1654
show_offset=False),
1608
1655
tags, self.merge_marker(revision)))
1609
1656
self.show_properties(revision.rev, indent+offset)
1657
if self.show_ids or revision.revno is None:
1611
1658
to_file.write(indent + offset + 'revision-id:%s\n'
1612
1659
% (revision.rev.revision_id,))
1613
1660
if not revision.rev.message:
1620
1667
if revision.delta is not None:
1621
1668
# Use the standard status output to display changes
1622
1669
from bzrlib.delta import report_delta
1623
report_delta(to_file, revision.delta,
1624
short_status=self.delta_format==1,
1670
report_delta(to_file, revision.delta,
1671
short_status=self.delta_format==1,
1625
1672
show_ids=self.show_ids, indent=indent + offset)
1626
1673
if revision.diff is not None:
1627
1674
self.show_diff(self.to_exact_file, revision.diff, ' ')
1667
1714
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1668
1715
"""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
1717
:param revno: revision number or None.
1718
Revision numbers counts from 1.
1719
:param rev: revision object
1720
:param max_chars: maximum length of resulting string
1721
:param tags: list of tags or None
1722
:param prefix: string to prefix each line
1723
:return: formatted truncated string
1679
1727
# show revno only when is not None
1680
1728
out.append("%s:" % revno)
1681
out.append(self.truncate(self.short_author(rev), 20))
1729
if max_chars is not None:
1730
out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
1732
out.append(self.short_author(rev))
1682
1733
out.append(self.date_string(rev))
1683
1734
if len(rev.parent_ids) > 1:
1684
1735
out.append('[merge]')
1703
1754
self.show_timezone,
1704
1755
date_fmt='%Y-%m-%d',
1705
1756
show_offset=False)
1706
committer_str = revision.rev.get_apparent_authors()[0].replace (' <', ' <')
1757
committer_str = self.authors(revision.rev, 'first', sep=', ')
1758
committer_str = committer_str.replace(' <', ' <')
1707
1759
to_file.write('%s %s\n\n' % (date_str,committer_str))
1709
1761
if revision.delta is not None and revision.delta.has_changed():
1742
1794
return self.get(name)(*args, **kwargs)
1744
1796
def get_default(self, branch):
1745
return self.get(branch.get_config().log_format())
1797
c = branch.get_config_stack()
1798
return self.get(c.get('log_format'))
1748
1801
log_formatter_registry = LogFormatterRegistry()
1751
1804
log_formatter_registry.register('short', ShortLogFormatter,
1752
'Moderately short log format')
1805
'Moderately short log format.')
1753
1806
log_formatter_registry.register('long', LongLogFormatter,
1754
'Detailed log format')
1807
'Detailed log format.')
1755
1808
log_formatter_registry.register('line', LineLogFormatter,
1756
'Log format with one line per revision')
1809
'Log format with one line per revision.')
1757
1810
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1758
'Format used by GNU ChangeLog files')
1811
'Format used by GNU ChangeLog files.')
1761
1814
def register_formatter(name, formatter):
1772
1825
return log_formatter_registry.make_formatter(name, *args, **kwargs)
1773
1826
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)
1827
raise errors.BzrCommandError(gettext("unknown log formatter: %r") % name)
1830
def author_list_all(rev):
1831
return rev.get_apparent_authors()[:]
1834
def author_list_first(rev):
1835
lst = rev.get_apparent_authors()
1842
def author_list_committer(rev):
1843
return [rev.committer]
1846
author_list_registry = registry.Registry()
1848
author_list_registry.register('all', author_list_all,
1851
author_list_registry.register('first', author_list_first,
1854
author_list_registry.register('committer', author_list_committer,
1783
1858
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1940
2016
:param file_list: the list of paths given on the command line;
1941
2017
the first of these can be a branch location or a file path,
1942
2018
the remainder must be file paths
2019
:param add_cleanup: When the branch returned is read locked,
2020
an unlock call will be queued to the cleanup.
1943
2021
:return: (branch, info_list, start_rev_info, end_rev_info) where
1944
2022
info_list is a list of (relative_path, file_id, kind) tuples where
1945
2023
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1946
2024
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])
2026
from bzrlib.builtins import _get_revision_range
2027
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2029
add_cleanup(b.lock_read().unlock)
1951
2030
# XXX: It's damn messy converting a list of paths to relative paths when
1952
2031
# those paths might be deleted ones, they might be on a case-insensitive
1953
2032
# filesystem and/or they might be in silly locations (like another branch).
added
removed
bzrlib/log.py
