65
65
lazy_import(globals(), """
67
67
from bzrlib import (
73
74
repository as _mod_repository,
74
75
revision as _mod_revision,
78
from bzrlib.i18n import gettext, ngettext
81
82
from bzrlib import (
85
85
from bzrlib.osutils import (
87
87
format_date_with_offset_in_original_timezone,
88
get_diff_header_encoding,
89
88
get_terminal_encoding,
91
from bzrlib.symbol_versioning import (
94
97
def find_touching_revisions(branch, file_id):
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):
111
for revision_id in branch.revision_history():
112
112
this_inv = branch.repository.get_inventory(revision_id)
113
if this_inv.has_id(file_id):
113
if file_id in this_inv:
114
114
this_ie = this_inv[file_id]
115
115
this_path = this_inv.id2path(file_id)
218
214
Logger(branch, rqst).show(lf)
221
# Note: This needs to be kept in sync with the defaults in
217
# Note: This needs to be kept this in sync with the defaults in
222
218
# make_log_request_dict() below
223
219
_DEFAULT_REQUEST_PARAMS = {
224
220
'direction': 'reverse',
226
222
'generate_tags': True,
227
223
'exclude_common_ancestry': False,
228
224
'_match_using_deltas': True,
232
228
def make_log_request_dict(direction='reverse', specific_fileids=None,
233
229
start_revision=None, end_revision=None, limit=None,
234
message_search=None, levels=None, generate_tags=True,
230
message_search=None, levels=1, generate_tags=True,
236
232
diff_type=None, _match_using_deltas=True,
237
exclude_common_ancestry=False, match=None,
238
signature=False, omit_merges=False,
233
exclude_common_ancestry=False,
240
235
"""Convenience function for making a logging request dictionary.
262
257
matching commit messages
264
259
:param levels: the number of levels of revisions to
265
generate; 1 for just the mainline; 0 for all levels, or None for
260
generate; 1 for just the mainline; 0 for all levels.
268
262
:param generate_tags: If True, include tags for matched revisions.
270
264
:param delta_type: Either 'full', 'partial' or None.
271
265
'full' means generate the complete delta - adds/deletes/modifies/etc;
272
266
'partial' means filter the delta using specific_fileids;
285
279
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
286
280
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] }
308
283
'direction': direction,
309
284
'specific_fileids': specific_fileids,
310
285
'start_revision': start_revision,
311
286
'end_revision': end_revision,
288
'message_search': message_search,
313
289
'levels': levels,
314
290
'generate_tags': generate_tags,
315
291
'delta_type': delta_type,
316
292
'diff_type': diff_type,
317
293
'exclude_common_ancestry': exclude_common_ancestry,
318
'signature': signature,
320
'omit_merges': omit_merges,
321
294
# Add 'private' attributes for features that may be deprecated
322
295
'_match_using_deltas': _match_using_deltas,
326
299
def _apply_log_request_defaults(rqst):
327
300
"""Apply default values to a request dictionary."""
328
result = _DEFAULT_REQUEST_PARAMS.copy()
301
result = _DEFAULT_REQUEST_PARAMS
330
303
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"
355
307
class LogGenerator(object):
356
308
"""A generator of log revisions."""
402
354
# Tweak the LogRequest based on what the LogFormatter can handle.
403
355
# (There's no point generating stuff if the formatter can't display it.)
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()
357
rqst['levels'] = lf.get_levels()
409
358
if not getattr(lf, 'supports_tags', False):
410
359
rqst['generate_tags'] = False
411
360
if not getattr(lf, 'supports_delta', False):
412
361
rqst['delta_type'] = None
413
362
if not getattr(lf, 'supports_diff', False):
414
363
rqst['diff_type'] = None
415
if not getattr(lf, 'supports_signatures', False):
416
rqst['signature'] = False
418
365
# Find and print the interesting revisions
419
366
generator = self._generator_factory(self.branch, rqst)
462
407
# 0 levels means show everything; merge_depth counts from 0
463
408
if levels != 0 and merge_depth >= levels:
465
if omit_merges and len(rev.parent_ids) > 1:
467
410
if diff_type is None:
470
413
diff = self._format_diff(rev, rev_id, diff_type)
472
signature = format_signature_validity(rev_id,
473
self.branch.repository)
476
414
yield LogRevision(rev, revno, merge_depth, delta,
477
self.rev_tag_dict.get(rev_id), diff, signature)
415
self.rev_tag_dict.get(rev_id), diff)
480
418
if log_count >= limit:
536
474
# Apply the other filters
537
475
return make_log_rev_iterator(self.branch, view_revisions,
538
rqst.get('delta_type'), rqst.get('match'),
476
rqst.get('delta_type'), rqst.get('message_search'),
539
477
file_ids=rqst.get('specific_fileids'),
540
478
direction=rqst.get('direction'))
554
492
rqst.get('specific_fileids')[0], view_revisions,
555
493
include_merges=rqst.get('levels') != 1)
556
494
return make_log_rev_iterator(self.branch, view_revisions,
557
rqst.get('delta_type'), rqst.get('match'))
495
rqst.get('delta_type'), rqst.get('message_search'))
560
498
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
568
506
a list of the same tuples.
570
508
if (exclude_common_ancestry and start_rev_id == end_rev_id):
571
raise errors.BzrCommandError(gettext(
572
'--exclude-common-ancestry requires two different revisions'))
509
raise errors.BzrCommandError(
510
'--exclude-common-ancestry requires two different revisions')
573
511
if direction not in ('reverse', 'forward'):
574
raise ValueError(gettext('invalid direction %r') % direction)
512
raise ValueError('invalid direction %r' % direction)
575
513
br_revno, br_rev_id = branch.last_revision_info()
576
514
if br_revno == 0:
580
518
and (not generate_merge_revisions
581
519
or not _has_merges(branch, end_rev_id))):
582
520
# If a single revision is requested, check we can handle it
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)))
521
iter_revs = _generate_one_revision(branch, end_rev_id, br_rev_id,
523
elif not generate_merge_revisions:
524
# If we only want to see linear revisions, we can iterate ...
525
iter_revs = _generate_flat_revisions(branch, start_rev_id, end_rev_id,
526
direction, exclude_common_ancestry)
527
if direction == 'forward':
528
iter_revs = reversed(iter_revs)
530
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
531
direction, delayed_graph_generation,
532
exclude_common_ancestry)
533
if direction == 'forward':
534
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
615
541
return [(br_rev_id, br_revno, 0)]
617
revno_str = _compute_revno_str(branch, rev_id)
543
revno = branch.revision_id_to_dotted_revno(rev_id)
544
revno_str = '.'.join(str(n) for n in revno)
618
545
return [(rev_id, revno_str, 0)]
548
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction,
549
exclude_common_ancestry=False):
550
result = _linear_view_revisions(
551
branch, start_rev_id, end_rev_id,
552
exclude_common_ancestry=exclude_common_ancestry)
553
# If a start limit was given and it's not obviously an
554
# ancestor of the end limit, check it before outputting anything
555
if direction == 'forward' or (start_rev_id
556
and not _is_obvious_ancestor(branch, start_rev_id, end_rev_id)):
558
result = list(result)
559
except _StartNotLinearAncestor:
560
raise errors.BzrCommandError('Start revision not found in'
561
' left-hand history of end revision.')
621
565
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
622
566
delayed_graph_generation,
623
567
exclude_common_ancestry=False):
659
603
except _StartNotLinearAncestor:
660
604
# A merge was never detected so the lower revision limit can't
661
605
# be nested down somewhere
662
raise errors.BzrCommandError(gettext('Start revision not found in'
663
' history of end revision.'))
606
raise errors.BzrCommandError('Start revision not found in'
607
' history of end revision.')
665
609
# We exit the loop above because we encounter a revision with merges, from
666
610
# this revision, we need to switch to _graph_view_revisions.
683
627
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)
701
630
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
702
631
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
703
632
if start_rev_id and 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
633
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
634
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
710
635
if len(start_dotted) == 1 and len(end_dotted) == 1:
711
636
# both on mainline
712
637
return start_dotted[0] <= end_dotted[0]
737
662
br_revno, br_rev_id = branch.last_revision_info()
738
663
repo = branch.repository
739
graph = repo.get_graph()
740
664
if start_rev_id is None and end_rev_id is None:
741
665
cur_revno = br_revno
742
for revision_id in graph.iter_lefthand_ancestry(br_rev_id,
743
(_mod_revision.NULL_REVISION,)):
666
for revision_id in repo.iter_reverse_revision_history(br_rev_id):
744
667
yield revision_id, str(cur_revno), 0
747
670
if end_rev_id is None:
748
671
end_rev_id = br_rev_id
749
672
found_start = start_rev_id is None
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)
673
for revision_id in repo.iter_reverse_revision_history(end_rev_id):
674
revno = branch.revision_id_to_dotted_revno(revision_id)
675
revno_str = '.'.join(str(n) for n in revno)
753
676
if not found_start and revision_id == start_rev_id:
754
677
if not exclude_common_ancestry:
755
678
yield revision_id, revno_str, 0
806
729
yield rev_id, '.'.join(map(str, revno)), merge_depth
732
@deprecated_function(deprecated_in((2, 2, 0)))
733
def calculate_view_revisions(branch, start_revision, end_revision, direction,
734
specific_fileid, generate_merge_revisions):
735
"""Calculate the revisions to view.
737
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
738
a list of the same tuples.
740
start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
742
view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
743
direction, generate_merge_revisions or specific_fileid))
745
view_revisions = _filter_revisions_touching_file_id(branch,
746
specific_fileid, view_revisions,
747
include_merges=generate_merge_revisions)
748
return _rebase_merge_depth(view_revisions)
809
751
def _rebase_merge_depth(view_revisions):
810
752
"""Adjust depths upwards so the top level is 0."""
811
753
# If either the first or last revision have a merge_depth of 0, we're done
855
797
return log_rev_iterator
858
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
800
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
859
801
"""Create a filtered iterator of log_rev_iterator matching on a regex.
861
803
:param branch: The branch being logged.
862
804
:param generate_delta: Whether to generate a delta for each revision.
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
805
:param search: A user text search string.
867
806
:param log_rev_iterator: An input iterator containing all revisions that
868
807
could be displayed, in lists.
869
808
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
873
812
return 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):
813
searchRE = re.compile(search, re.IGNORECASE)
814
return _filter_message_re(searchRE, log_rev_iterator)
817
def _filter_message_re(searchRE, log_rev_iterator):
880
818
for revs in log_rev_iterator:
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])
820
for (rev_id, revno, merge_depth), rev, delta in revs:
821
if searchRE.search(rev.message):
822
new_revs.append(((rev_id, revno, merge_depth), rev, delta))
902
826
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
903
827
fileids=None, direction='reverse'):
1077
1002
if branch_revno != 0:
1078
1003
if (start_rev_id == _mod_revision.NULL_REVISION
1079
1004
or end_rev_id == _mod_revision.NULL_REVISION):
1080
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1005
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1081
1006
if start_revno > end_revno:
1082
raise errors.BzrCommandError(gettext("Start revision must be "
1083
"older than the end revision."))
1007
raise errors.BzrCommandError("Start revision must be older than "
1008
"the end revision.")
1084
1009
return (start_rev_id, end_rev_id)
1136
1061
if ((start_rev_id == _mod_revision.NULL_REVISION)
1137
1062
or (end_rev_id == _mod_revision.NULL_REVISION)):
1138
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1063
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1139
1064
if start_revno > end_revno:
1140
raise errors.BzrCommandError(gettext("Start revision must be older "
1141
"than the end revision."))
1065
raise errors.BzrCommandError("Start revision must be older than "
1066
"the end revision.")
1143
1068
if end_revno < start_revno:
1144
1069
return None, None, None, None
1145
1070
cur_revno = branch_revno
1147
1072
mainline_revs = []
1148
graph = branch.repository.get_graph()
1149
for revision_id in graph.iter_lefthand_ancestry(
1150
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1073
for revision_id in branch.repository.iter_reverse_revision_history(
1074
branch_last_revision):
1151
1075
if cur_revno < start_revno:
1152
1076
# We have gone far enough, but we always add 1 more revision
1153
1077
rev_nos[revision_id] = cur_revno
1167
1091
return mainline_revs, rev_nos, start_rev_id, end_rev_id
1094
@deprecated_function(deprecated_in((2, 2, 0)))
1095
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1096
"""Filter view_revisions based on revision ranges.
1098
:param view_revisions: A list of (revision_id, dotted_revno, merge_depth)
1099
tuples to be filtered.
1101
:param start_rev_id: If not NONE specifies the first revision to be logged.
1102
If NONE then all revisions up to the end_rev_id are logged.
1104
:param end_rev_id: If not NONE specifies the last revision to be logged.
1105
If NONE then all revisions up to the end of the log are logged.
1107
:return: The filtered view_revisions.
1109
if start_rev_id or end_rev_id:
1110
revision_ids = [r for r, n, d in view_revisions]
1112
start_index = revision_ids.index(start_rev_id)
1115
if start_rev_id == end_rev_id:
1116
end_index = start_index
1119
end_index = revision_ids.index(end_rev_id)
1121
end_index = len(view_revisions) - 1
1122
# To include the revisions merged into the last revision,
1123
# extend end_rev_id down to, but not including, the next rev
1124
# with the same or lesser merge_depth
1125
end_merge_depth = view_revisions[end_index][2]
1127
for index in xrange(end_index+1, len(view_revisions)+1):
1128
if view_revisions[index][2] <= end_merge_depth:
1129
end_index = index - 1
1132
# if the search falls off the end then log to the end as well
1133
end_index = len(view_revisions) - 1
1134
view_revisions = view_revisions[start_index:end_index+1]
1135
return view_revisions
1170
1138
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1171
1139
include_merges=True):
1172
1140
r"""Return the list of revision ids which touch a given file id.
1219
1184
# indexing layer. We might consider passing in hints as to the known
1220
1185
# access pattern (sparse/clustered, high success rate/low success
1221
1186
# rate). This particular access is clustered with a low success rate.
1187
get_parent_map = branch.repository.texts.get_parent_map
1222
1188
modified_text_revisions = set()
1223
1189
chunk_size = 1000
1224
1190
for start in xrange(0, len(text_keys), chunk_size):
1220
@deprecated_function(deprecated_in((2, 2, 0)))
1221
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1222
include_merges=True):
1223
"""Produce an iterator of revisions to show
1224
:return: an iterator of (revision_id, revno, merge_depth)
1225
(if there is no revno for a revision, None is supplied)
1227
if not include_merges:
1228
revision_ids = mainline_revs[1:]
1229
if direction == 'reverse':
1230
revision_ids.reverse()
1231
for revision_id in revision_ids:
1232
yield revision_id, str(rev_nos[revision_id]), 0
1234
graph = branch.repository.get_graph()
1235
# This asks for all mainline revisions, which means we only have to spider
1236
# sideways, rather than depth history. That said, its still size-of-history
1237
# and should be addressed.
1238
# mainline_revisions always includes an extra revision at the beginning, so
1240
parent_map = dict(((key, value) for key, value in
1241
graph.iter_ancestry(mainline_revs[1:]) if value is not None))
1242
# filter out ghosts; merge_sort errors on ghosts.
1243
rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
1244
merge_sorted_revisions = tsort.merge_sort(
1248
generate_revno=True)
1250
if direction == 'forward':
1251
# forward means oldest first.
1252
merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
1253
elif direction != 'reverse':
1254
raise ValueError('invalid direction %r' % direction)
1256
for (sequence, rev_id, merge_depth, revno, end_of_merge
1257
) in merge_sorted_revisions:
1258
yield rev_id, '.'.join(map(str, revno)), merge_depth
1254
1261
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1262
"""Reverse revisions by depth.
1293
1300
def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
1294
tags=None, diff=None, signature=None):
1301
tags=None, diff=None):
1299
self.revno = str(revno)
1303
self.revno = str(revno)
1300
1304
self.merge_depth = merge_depth
1301
1305
self.delta = delta
1302
1306
self.tags = tags
1303
1307
self.diff = diff
1304
self.signature = signature
1307
1310
class LogFormatter(object):
1316
1319
to indicate which LogRevision attributes it supports:
1318
1321
- supports_delta must be True if this log formatter supports delta.
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.
1322
Otherwise the delta attribute may not be populated. The 'delta_format'
1323
attribute describes whether the 'short_status' format (1) or the long
1324
one (2) should be used.
1323
1326
- supports_merge_revisions must be True if this log formatter supports
1324
merge revisions. If not, then only mainline revisions will be passed
1327
merge revisions. If not, then only mainline revisions will be passed
1327
1330
- preferred_levels is the number of levels this formatter defaults to.
1328
The default value is zero meaning display all levels.
1329
This value is only relevant if supports_merge_revisions is True.
1331
The default value is zero meaning display all levels.
1332
This value is only relevant if supports_merge_revisions is True.
1331
1334
- supports_tags must be True if this log formatter supports tags.
1332
Otherwise the tags attribute may not be populated.
1335
Otherwise the tags attribute may not be populated.
1334
1337
- supports_diff must be True if this log formatter supports diffs.
1335
Otherwise the diff attribute may not be populated.
1337
- supports_signatures must be True if this log formatter supports GPG
1338
Otherwise the diff attribute may not be populated.
1340
1340
Plugins can register functions to show custom revision properties using
1341
1341
the properties_handler_registry. The registered function
1342
must respect the following interface description::
1342
must respect the following interface description:
1344
1343
def my_show_properties(properties_dict):
1345
1344
# code that returns a dict {'name':'value'} of the properties
1353
1352
"""Create a LogFormatter.
1355
1354
:param to_file: the file to output to
1356
:param to_exact_file: if set, gives an output stream to which
1355
:param to_exact_file: if set, gives an output stream to which
1357
1356
non-Unicode diffs are written.
1358
1357
:param show_ids: if True, revision-ids are to be displayed
1359
1358
:param show_timezone: the timezone to use
1559
1557
self.merge_marker(revision)))
1560
1558
if revision.tags:
1561
1559
lines.append('tags: %s' % (', '.join(revision.tags)))
1562
if self.show_ids or revision.revno is None:
1563
1561
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1565
1562
for parent_id in revision.rev.parent_ids:
1566
1563
lines.append('parent: %s' % (parent_id,))
1567
1564
lines.extend(self.custom_properties(revision.rev))
1595
1589
if revision.delta is not None:
1596
1590
# Use the standard status output to display changes
1597
1591
from bzrlib.delta import report_delta
1598
report_delta(to_file, revision.delta, short_status=False,
1592
report_delta(to_file, revision.delta, short_status=False,
1599
1593
show_ids=self.show_ids, indent=indent)
1600
1594
if revision.diff is not None:
1601
1595
to_file.write(indent + 'diff:\n')
1647
1641
if revision.tags:
1648
1642
tags = ' {%s}' % (', '.join(revision.tags))
1649
1643
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1650
revision.revno or "", self.short_author(revision.rev),
1644
revision.revno, self.short_author(revision.rev),
1651
1645
format_date(revision.rev.timestamp,
1652
1646
revision.rev.timezone or 0,
1653
1647
self.show_timezone, date_fmt="%Y-%m-%d",
1654
1648
show_offset=False),
1655
1649
tags, self.merge_marker(revision)))
1656
1650
self.show_properties(revision.rev, indent+offset)
1657
if self.show_ids or revision.revno is None:
1658
1652
to_file.write(indent + offset + 'revision-id:%s\n'
1659
1653
% (revision.rev.revision_id,))
1660
1654
if not revision.rev.message:
1667
1661
if revision.delta is not None:
1668
1662
# Use the standard status output to display changes
1669
1663
from bzrlib.delta import report_delta
1670
report_delta(to_file, revision.delta,
1671
short_status=self.delta_format==1,
1664
report_delta(to_file, revision.delta,
1665
short_status=self.delta_format==1,
1672
1666
show_ids=self.show_ids, indent=indent + offset)
1673
1667
if revision.diff is not None:
1674
1668
self.show_diff(self.to_exact_file, revision.diff, ' ')
1714
1708
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1715
1709
"""Format log info into one string. Truncate tail of 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
1710
:param revno: revision number or None.
1711
Revision numbers counts from 1.
1712
:param rev: revision object
1713
:param max_chars: maximum length of resulting string
1714
:param tags: list of tags or None
1715
:param prefix: string to prefix each line
1716
:return: formatted truncated string
1727
1720
# show revno only when is not None
1728
1721
out.append("%s:" % revno)
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))
1722
out.append(self.truncate(self.short_author(rev), 20))
1733
1723
out.append(self.date_string(rev))
1734
1724
if len(rev.parent_ids) > 1:
1735
1725
out.append('[merge]')
1794
1784
return self.get(name)(*args, **kwargs)
1796
1786
def get_default(self, branch):
1797
c = branch.get_config_stack()
1798
return self.get(c.get('log_format'))
1787
return self.get(branch.get_config().log_format())
1801
1790
log_formatter_registry = LogFormatterRegistry()
1804
1793
log_formatter_registry.register('short', ShortLogFormatter,
1805
'Moderately short log format.')
1794
'Moderately short log format')
1806
1795
log_formatter_registry.register('long', LongLogFormatter,
1807
'Detailed log format.')
1796
'Detailed log format')
1808
1797
log_formatter_registry.register('line', LineLogFormatter,
1809
'Log format with one line per revision.')
1798
'Log format with one line per revision')
1810
1799
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1811
'Format used by GNU ChangeLog files.')
1800
'Format used by GNU ChangeLog files')
1814
1803
def register_formatter(name, formatter):
1855
1844
'The committer')
1847
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1848
# deprecated; for compatibility
1849
lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
1850
lf.show(revno, rev, delta)
1858
1853
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1859
1854
log_format='long'):
1860
1855
"""Show the change in revision history comparing the old revision history to the new one.
2023
2017
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2024
2018
branch will be read-locked.
2026
from bzrlib.builtins import _get_revision_range
2027
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2020
from builtins import _get_revision_range
2021
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2029
2022
add_cleanup(b.lock_read().unlock)
2030
2023
# XXX: It's damn messy converting a list of paths to relative paths when
2031
2024
# those paths might be deleted ones, they might be on a case-insensitive
added
removed
bzrlib/log.py
