65
65
lazy_import(globals(), """
67
67
from bzrlib import (
74
73
repository as _mod_repository,
75
74
revision as _mod_revision,
78
from bzrlib.i18n import gettext, ngettext
82
81
from bzrlib import (
85
85
from bzrlib.osutils import (
87
87
format_date_with_offset_in_original_timezone,
88
get_diff_header_encoding,
88
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
209
Logger(branch, rqst).show(lf)
217
# Note: This needs to be kept this in sync with the defaults in
212
# Note: This needs to be kept in sync with the defaults in
218
213
# make_log_request_dict() below
219
214
_DEFAULT_REQUEST_PARAMS = {
220
215
'direction': 'reverse',
222
217
'generate_tags': True,
223
218
'exclude_common_ancestry': False,
224
219
'_match_using_deltas': True,
228
223
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
224
start_revision=None, end_revision=None, limit=None,
230
message_search=None, levels=1, generate_tags=True,
225
message_search=None, levels=None, generate_tags=True,
232
227
diff_type=None, _match_using_deltas=True,
233
exclude_common_ancestry=False,
228
exclude_common_ancestry=False, match=None,
229
signature=False, omit_merges=False,
235
231
"""Convenience function for making a logging request dictionary.
257
253
matching commit messages
259
255
:param levels: the number of levels of revisions to
260
generate; 1 for just the mainline; 0 for all levels.
256
generate; 1 for just the mainline; 0 for all levels, or None for
262
259
:param generate_tags: If True, include tags for matched revisions.
264
261
:param delta_type: Either 'full', 'partial' or None.
265
262
'full' means generate the complete delta - adds/deletes/modifies/etc;
266
263
'partial' means filter the delta using specific_fileids;
279
276
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
277
range operator or as a graph difference.
279
:param signature: show digital signature information
281
:param match: Dictionary of list of search strings to use when filtering
282
revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
283
the empty string to match any of the preceding properties.
285
:param omit_merges: If True, commits with more than one parent are
289
# Take care of old style message_search parameter
292
if 'message' in match:
293
match['message'].append(message_search)
295
match['message'] = [message_search]
297
match={ 'message': [message_search] }
283
299
'direction': direction,
284
300
'specific_fileids': specific_fileids,
285
301
'start_revision': start_revision,
286
302
'end_revision': end_revision,
288
'message_search': message_search,
289
304
'levels': levels,
290
305
'generate_tags': generate_tags,
291
306
'delta_type': delta_type,
292
307
'diff_type': diff_type,
293
308
'exclude_common_ancestry': exclude_common_ancestry,
309
'signature': signature,
311
'omit_merges': omit_merges,
294
312
# Add 'private' attributes for features that may be deprecated
295
313
'_match_using_deltas': _match_using_deltas,
299
317
def _apply_log_request_defaults(rqst):
300
318
"""Apply default values to a request dictionary."""
301
result = _DEFAULT_REQUEST_PARAMS
319
result = _DEFAULT_REQUEST_PARAMS.copy()
303
321
result.update(rqst)
325
def format_signature_validity(rev_id, repo):
326
"""get the signature validity
328
:param rev_id: revision id to validate
329
:param repo: repository of revision
330
:return: human readable string to print to log
332
from bzrlib import gpg
334
gpg_strategy = gpg.GPGStrategy(None)
335
result = repo.verify_revision_signature(rev_id, gpg_strategy)
336
if result[0] == gpg.SIGNATURE_VALID:
337
return u"valid signature from {0}".format(result[1])
338
if result[0] == gpg.SIGNATURE_KEY_MISSING:
339
return "unknown key {0}".format(result[1])
340
if result[0] == gpg.SIGNATURE_NOT_VALID:
341
return "invalid signature!"
342
if result[0] == gpg.SIGNATURE_NOT_SIGNED:
343
return "no signature"
307
346
class LogGenerator(object):
308
347
"""A generator of log revisions."""
354
393
# Tweak the LogRequest based on what the LogFormatter can handle.
355
394
# (There's no point generating stuff if the formatter can't display it.)
357
rqst['levels'] = lf.get_levels()
396
if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
397
# user didn't specify levels, use whatever the LF can handle:
398
rqst['levels'] = lf.get_levels()
358
400
if not getattr(lf, 'supports_tags', False):
359
401
rqst['generate_tags'] = False
360
402
if not getattr(lf, 'supports_delta', False):
361
403
rqst['delta_type'] = None
362
404
if not getattr(lf, 'supports_diff', False):
363
405
rqst['diff_type'] = None
406
if not getattr(lf, 'supports_signatures', False):
407
rqst['signature'] = False
365
409
# Find and print the interesting revisions
366
410
generator = self._generator_factory(self.branch, rqst)
407
453
# 0 levels means show everything; merge_depth counts from 0
408
454
if levels != 0 and merge_depth >= levels:
456
if omit_merges and len(rev.parent_ids) > 1:
410
458
if diff_type is None:
413
461
diff = self._format_diff(rev, rev_id, diff_type)
463
signature = format_signature_validity(rev_id,
464
self.branch.repository)
414
467
yield LogRevision(rev, revno, merge_depth, delta,
415
self.rev_tag_dict.get(rev_id), diff)
468
self.rev_tag_dict.get(rev_id), diff, signature)
418
471
if log_count >= limit:
474
527
# Apply the other filters
475
528
return make_log_rev_iterator(self.branch, view_revisions,
476
rqst.get('delta_type'), rqst.get('message_search'),
529
rqst.get('delta_type'), rqst.get('match'),
477
530
file_ids=rqst.get('specific_fileids'),
478
531
direction=rqst.get('direction'))
492
545
rqst.get('specific_fileids')[0], view_revisions,
493
546
include_merges=rqst.get('levels') != 1)
494
547
return make_log_rev_iterator(self.branch, view_revisions,
495
rqst.get('delta_type'), rqst.get('message_search'))
548
rqst.get('delta_type'), rqst.get('match'))
498
551
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
506
559
a list of the same tuples.
508
561
if (exclude_common_ancestry and start_rev_id == end_rev_id):
509
raise errors.BzrCommandError(
510
'--exclude-common-ancestry requires two different revisions')
562
raise errors.BzrCommandError(gettext(
563
'--exclude-common-ancestry requires two different revisions'))
511
564
if direction not in ('reverse', 'forward'):
512
raise ValueError('invalid direction %r' % direction)
565
raise ValueError(gettext('invalid direction %r') % direction)
513
566
br_revno, br_rev_id = branch.last_revision_info()
514
567
if br_revno == 0:
518
571
and (not generate_merge_revisions
519
572
or not _has_merges(branch, end_rev_id))):
520
573
# If a single revision is requested, check we can handle it
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)))
574
return _generate_one_revision(branch, end_rev_id, br_rev_id,
576
if not generate_merge_revisions:
578
# If we only want to see linear revisions, we can iterate ...
579
iter_revs = _linear_view_revisions(
580
branch, start_rev_id, end_rev_id,
581
exclude_common_ancestry=exclude_common_ancestry)
582
# If a start limit was given and it's not obviously an
583
# ancestor of the end limit, check it before outputting anything
584
if (direction == 'forward'
585
or (start_rev_id and not _is_obvious_ancestor(
586
branch, start_rev_id, end_rev_id))):
587
iter_revs = list(iter_revs)
588
if direction == 'forward':
589
iter_revs = reversed(iter_revs)
591
except _StartNotLinearAncestor:
592
# Switch to the slower implementation that may be able to find a
593
# non-obvious ancestor out of the left-hand history.
595
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
596
direction, delayed_graph_generation,
597
exclude_common_ancestry)
598
if direction == 'forward':
599
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
541
606
return [(br_rev_id, br_revno, 0)]
543
revno = branch.revision_id_to_dotted_revno(rev_id)
544
revno_str = '.'.join(str(n) for n in revno)
608
revno_str = _compute_revno_str(branch, rev_id)
545
609
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.')
565
612
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
566
613
delayed_graph_generation,
567
614
exclude_common_ancestry=False):
603
650
except _StartNotLinearAncestor:
604
651
# A merge was never detected so the lower revision limit can't
605
652
# be nested down somewhere
606
raise errors.BzrCommandError('Start revision not found in'
607
' history of end revision.')
653
raise errors.BzrCommandError(gettext('Start revision not found in'
654
' history of end revision.'))
609
656
# We exit the loop above because we encounter a revision with merges, from
610
657
# this revision, we need to switch to _graph_view_revisions.
627
674
return len(parents) > 1
677
def _compute_revno_str(branch, rev_id):
678
"""Compute the revno string from a rev_id.
680
:return: The revno string, or None if the revision is not in the supplied
684
revno = branch.revision_id_to_dotted_revno(rev_id)
685
except errors.NoSuchRevision:
686
# The revision must be outside of this branch
689
return '.'.join(str(n) for n in revno)
630
692
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
631
693
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
632
694
if start_rev_id and end_rev_id:
633
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
634
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
696
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
697
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
698
except errors.NoSuchRevision:
699
# one or both is not in the branch; not obvious
635
701
if len(start_dotted) == 1 and len(end_dotted) == 1:
636
702
# both on mainline
637
703
return start_dotted[0] <= end_dotted[0]
662
728
br_revno, br_rev_id = branch.last_revision_info()
663
729
repo = branch.repository
730
graph = repo.get_graph()
664
731
if start_rev_id is None and end_rev_id is None:
665
732
cur_revno = br_revno
666
for revision_id in repo.iter_reverse_revision_history(br_rev_id):
733
for revision_id in graph.iter_lefthand_ancestry(br_rev_id,
734
(_mod_revision.NULL_REVISION,)):
667
735
yield revision_id, str(cur_revno), 0
670
738
if end_rev_id is None:
671
739
end_rev_id = br_rev_id
672
740
found_start = start_rev_id is None
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)
741
for revision_id in graph.iter_lefthand_ancestry(end_rev_id,
742
(_mod_revision.NULL_REVISION,)):
743
revno_str = _compute_revno_str(branch, revision_id)
676
744
if not found_start and revision_id == start_rev_id:
677
745
if not exclude_common_ancestry:
678
746
yield revision_id, revno_str, 0
729
797
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)
751
800
def _rebase_merge_depth(view_revisions):
752
801
"""Adjust depths upwards so the top level is 0."""
753
802
# If either the first or last revision have a merge_depth of 0, we're done
797
846
return log_rev_iterator
800
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
849
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
801
850
"""Create a filtered iterator of log_rev_iterator matching on a regex.
803
852
:param branch: The branch being logged.
804
853
:param generate_delta: Whether to generate a delta for each revision.
805
:param search: A user text search string.
854
:param match: A dictionary with properties as keys and lists of strings
855
as values. To match, a revision may match any of the supplied strings
856
within a single property but must match at least one string for each
806
858
:param log_rev_iterator: An input iterator containing all revisions that
807
859
could be displayed, in lists.
808
860
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
812
864
return 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):
865
searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
866
for (k,v) in match.iteritems()]
867
return _filter_re(searchRE, log_rev_iterator)
870
def _filter_re(searchRE, log_rev_iterator):
818
871
for revs in log_rev_iterator:
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))
872
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
876
def _match_filter(searchRE, rev):
878
'message': (rev.message,),
879
'committer': (rev.committer,),
880
'author': (rev.get_apparent_authors()),
881
'bugs': list(rev.iter_bugs())
883
strings[''] = [item for inner_list in strings.itervalues()
884
for item in inner_list]
885
for (k,v) in searchRE:
886
if k in strings and not _match_any_filter(strings[k], v):
890
def _match_any_filter(strings, res):
891
return any([filter(None, map(re.search, strings)) for re in res])
826
893
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
827
894
fileids=None, direction='reverse'):
1002
1068
if branch_revno != 0:
1003
1069
if (start_rev_id == _mod_revision.NULL_REVISION
1004
1070
or end_rev_id == _mod_revision.NULL_REVISION):
1005
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1071
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1006
1072
if start_revno > end_revno:
1007
raise errors.BzrCommandError("Start revision must be older than "
1008
"the end revision.")
1073
raise errors.BzrCommandError(gettext("Start revision must be "
1074
"older than the end revision."))
1009
1075
return (start_rev_id, end_rev_id)
1061
1127
if ((start_rev_id == _mod_revision.NULL_REVISION)
1062
1128
or (end_rev_id == _mod_revision.NULL_REVISION)):
1063
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1129
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1064
1130
if start_revno > end_revno:
1065
raise errors.BzrCommandError("Start revision must be older than "
1066
"the end revision.")
1131
raise errors.BzrCommandError(gettext("Start revision must be older "
1132
"than the end revision."))
1068
1134
if end_revno < start_revno:
1069
1135
return None, None, None, None
1070
1136
cur_revno = branch_revno
1072
1138
mainline_revs = []
1073
for revision_id in branch.repository.iter_reverse_revision_history(
1074
branch_last_revision):
1139
graph = branch.repository.get_graph()
1140
for revision_id in graph.iter_lefthand_ancestry(
1141
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1075
1142
if cur_revno < start_revno:
1076
1143
# We have gone far enough, but we always add 1 more revision
1077
1144
rev_nos[revision_id] = cur_revno
1091
1158
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
1138
1161
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1139
1162
include_merges=True):
1140
1163
r"""Return the list of revision ids which touch a given file id.
1184
1210
# indexing layer. We might consider passing in hints as to the known
1185
1211
# access pattern (sparse/clustered, high success rate/low success
1186
1212
# rate). This particular access is clustered with a low success rate.
1187
get_parent_map = branch.repository.texts.get_parent_map
1188
1213
modified_text_revisions = set()
1189
1214
chunk_size = 1000
1190
1215
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
1261
1245
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1262
1246
"""Reverse revisions by depth.
1300
1284
def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
1301
tags=None, diff=None):
1285
tags=None, diff=None, signature=None):
1303
self.revno = str(revno)
1290
self.revno = str(revno)
1304
1291
self.merge_depth = merge_depth
1305
1292
self.delta = delta
1306
1293
self.tags = tags
1307
1294
self.diff = diff
1295
self.signature = signature
1310
1298
class LogFormatter(object):
1319
1307
to indicate which LogRevision attributes it supports:
1321
1309
- supports_delta must be True if this log formatter supports delta.
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.
1310
Otherwise the delta attribute may not be populated. The 'delta_format'
1311
attribute describes whether the 'short_status' format (1) or the long
1312
one (2) should be used.
1326
1314
- supports_merge_revisions must be True if this log formatter supports
1327
merge revisions. If not, then only mainline revisions will be passed
1315
merge revisions. If not, then only mainline revisions will be passed
1330
1318
- preferred_levels is the number of levels this formatter defaults to.
1331
The default value is zero meaning display all levels.
1332
This value is only relevant if supports_merge_revisions is True.
1319
The default value is zero meaning display all levels.
1320
This value is only relevant if supports_merge_revisions is True.
1334
1322
- supports_tags must be True if this log formatter supports tags.
1335
Otherwise the tags attribute may not be populated.
1323
Otherwise the tags attribute may not be populated.
1337
1325
- supports_diff must be True if this log formatter supports diffs.
1338
Otherwise the diff attribute may not be populated.
1326
Otherwise the diff attribute may not be populated.
1328
- supports_signatures must be True if this log formatter supports GPG
1340
1331
Plugins can register functions to show custom revision properties using
1341
1332
the properties_handler_registry. The registered function
1342
must respect the following interface description:
1333
must respect the following interface description::
1343
1335
def my_show_properties(properties_dict):
1344
1336
# code that returns a dict {'name':'value'} of the properties
1352
1344
"""Create a LogFormatter.
1354
1346
:param to_file: the file to output to
1355
:param to_exact_file: if set, gives an output stream to which
1347
:param to_exact_file: if set, gives an output stream to which
1356
1348
non-Unicode diffs are written.
1357
1349
:param show_ids: if True, revision-ids are to be displayed
1358
1350
:param show_timezone: the timezone to use
1557
1550
self.merge_marker(revision)))
1558
1551
if revision.tags:
1559
1552
lines.append('tags: %s' % (', '.join(revision.tags)))
1553
if self.show_ids or revision.revno is None:
1561
1554
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1562
1556
for parent_id in revision.rev.parent_ids:
1563
1557
lines.append('parent: %s' % (parent_id,))
1564
1558
lines.extend(self.custom_properties(revision.rev))
1589
1586
if revision.delta is not None:
1590
1587
# Use the standard status output to display changes
1591
1588
from bzrlib.delta import report_delta
1592
report_delta(to_file, revision.delta, short_status=False,
1589
report_delta(to_file, revision.delta, short_status=False,
1593
1590
show_ids=self.show_ids, indent=indent)
1594
1591
if revision.diff is not None:
1595
1592
to_file.write(indent + 'diff:\n')
1641
1638
if revision.tags:
1642
1639
tags = ' {%s}' % (', '.join(revision.tags))
1643
1640
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1644
revision.revno, self.short_author(revision.rev),
1641
revision.revno or "", self.short_author(revision.rev),
1645
1642
format_date(revision.rev.timestamp,
1646
1643
revision.rev.timezone or 0,
1647
1644
self.show_timezone, date_fmt="%Y-%m-%d",
1648
1645
show_offset=False),
1649
1646
tags, self.merge_marker(revision)))
1650
1647
self.show_properties(revision.rev, indent+offset)
1648
if self.show_ids or revision.revno is None:
1652
1649
to_file.write(indent + offset + 'revision-id:%s\n'
1653
1650
% (revision.rev.revision_id,))
1654
1651
if not revision.rev.message:
1661
1658
if revision.delta is not None:
1662
1659
# Use the standard status output to display changes
1663
1660
from bzrlib.delta import report_delta
1664
report_delta(to_file, revision.delta,
1665
short_status=self.delta_format==1,
1661
report_delta(to_file, revision.delta,
1662
short_status=self.delta_format==1,
1666
1663
show_ids=self.show_ids, indent=indent + offset)
1667
1664
if revision.diff is not None:
1668
1665
self.show_diff(self.to_exact_file, revision.diff, ' ')
1708
1705
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1709
1706
"""Format log info into one string. Truncate tail of 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
1708
:param revno: revision number or None.
1709
Revision numbers counts from 1.
1710
:param rev: revision object
1711
:param max_chars: maximum length of resulting string
1712
:param tags: list of tags or None
1713
:param prefix: string to prefix each line
1714
:return: formatted truncated string
1720
1718
# show revno only when is not None
1721
1719
out.append("%s:" % revno)
1722
out.append(self.truncate(self.short_author(rev), 20))
1720
if max_chars is not None:
1721
out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
1723
out.append(self.short_author(rev))
1723
1724
out.append(self.date_string(rev))
1724
1725
if len(rev.parent_ids) > 1:
1725
1726
out.append('[merge]')
1784
1785
return self.get(name)(*args, **kwargs)
1786
1787
def get_default(self, branch):
1787
return self.get(branch.get_config().log_format())
1788
c = branch.get_config_stack()
1789
return self.get(c.get('log_format'))
1790
1792
log_formatter_registry = LogFormatterRegistry()
1793
1795
log_formatter_registry.register('short', ShortLogFormatter,
1794
'Moderately short log format')
1796
'Moderately short log format.')
1795
1797
log_formatter_registry.register('long', LongLogFormatter,
1796
'Detailed log format')
1798
'Detailed log format.')
1797
1799
log_formatter_registry.register('line', LineLogFormatter,
1798
'Log format with one line per revision')
1800
'Log format with one line per revision.')
1799
1801
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1800
'Format used by GNU ChangeLog files')
1802
'Format used by GNU ChangeLog files.')
1803
1805
def register_formatter(name, formatter):
1844
1846
'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)
1853
1849
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1854
1850
log_format='long'):
1855
1851
"""Show the change in revision history comparing the old revision history to the new one.
2017
2014
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2018
2015
branch will be read-locked.
2020
from builtins import _get_revision_range
2021
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2017
from bzrlib.builtins import _get_revision_range
2018
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2022
2020
add_cleanup(b.lock_read().unlock)
2023
2021
# XXX: It's damn messy converting a list of paths to relative paths when
2024
2022
# those paths might be deleted ones, they might be on a case-insensitive
added
removed
bzrlib/log.py
