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 (
85
84
from bzrlib.osutils import (
87
86
format_date_with_offset_in_original_timezone,
88
get_diff_header_encoding,
89
87
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
473
# Apply the other filters
537
474
return make_log_rev_iterator(self.branch, view_revisions,
538
rqst.get('delta_type'), rqst.get('match'),
475
rqst.get('delta_type'), rqst.get('message_search'),
539
476
file_ids=rqst.get('specific_fileids'),
540
477
direction=rqst.get('direction'))
554
491
rqst.get('specific_fileids')[0], view_revisions,
555
492
include_merges=rqst.get('levels') != 1)
556
493
return make_log_rev_iterator(self.branch, view_revisions,
557
rqst.get('delta_type'), rqst.get('match'))
494
rqst.get('delta_type'), rqst.get('message_search'))
560
497
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
568
505
a list of the same tuples.
570
507
if (exclude_common_ancestry and start_rev_id == end_rev_id):
571
raise errors.BzrCommandError(gettext(
572
'--exclude-common-ancestry requires two different revisions'))
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
573
510
if direction not in ('reverse', 'forward'):
574
raise ValueError(gettext('invalid direction %r') % direction)
511
raise ValueError('invalid direction %r' % direction)
575
512
br_revno, br_rev_id = branch.last_revision_info()
576
513
if br_revno == 0:
585
522
elif not generate_merge_revisions:
586
523
# If we only want to see linear revisions, we can iterate ...
587
524
iter_revs = _generate_flat_revisions(branch, start_rev_id, end_rev_id,
588
direction, exclude_common_ancestry)
589
526
if direction == 'forward':
590
527
iter_revs = reversed(iter_revs)
603
540
return [(br_rev_id, br_revno, 0)]
605
revno_str = _compute_revno_str(branch, rev_id)
542
revno = branch.revision_id_to_dotted_revno(rev_id)
543
revno_str = '.'.join(str(n) for n in revno)
606
544
return [(rev_id, revno_str, 0)]
609
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction,
610
exclude_common_ancestry=False):
611
result = _linear_view_revisions(
612
branch, start_rev_id, end_rev_id,
613
exclude_common_ancestry=exclude_common_ancestry)
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)
614
549
# If a start limit was given and it's not obviously an
615
550
# ancestor of the end limit, check it before outputting anything
616
551
if direction == 'forward' or (start_rev_id
637
572
if delayed_graph_generation:
639
574
for rev_id, revno, depth in _linear_view_revisions(
640
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
575
branch, start_rev_id, end_rev_id):
641
576
if _has_merges(branch, rev_id):
642
577
# The end_rev_id can be nested down somewhere. We need an
643
578
# explicit ancestry check. There is an ambiguity here as we
664
599
except _StartNotLinearAncestor:
665
600
# A merge was never detected so the lower revision limit can't
666
601
# be nested down somewhere
667
raise errors.BzrCommandError(gettext('Start revision not found in'
668
' history of end revision.'))
602
raise errors.BzrCommandError('Start revision not found in'
603
' history of end revision.')
670
605
# We exit the loop above because we encounter a revision with merges, from
671
606
# this revision, we need to switch to _graph_view_revisions.
688
623
return len(parents) > 1
691
def _compute_revno_str(branch, rev_id):
692
"""Compute the revno string from a rev_id.
694
:return: The revno string, or None if the revision is not in the supplied
698
revno = branch.revision_id_to_dotted_revno(rev_id)
699
except errors.NoSuchRevision:
700
# The revision must be outside of this branch
703
return '.'.join(str(n) for n in revno)
706
626
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
707
627
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
708
628
if start_rev_id and end_rev_id:
710
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
711
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
712
except errors.NoSuchRevision:
713
# one or both is not in the branch; not obvious
629
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
630
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
715
631
if len(start_dotted) == 1 and len(end_dotted) == 1:
716
632
# both on mainline
717
633
return start_dotted[0] <= end_dotted[0]
730
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
731
exclude_common_ancestry=False):
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
732
647
"""Calculate a sequence of revisions to view, newest to oldest.
734
649
:param start_rev_id: the lower revision-id
735
650
:param end_rev_id: the upper revision-id
736
:param exclude_common_ancestry: Whether the start_rev_id should be part of
737
the iterated revisions.
738
651
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
739
652
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
740
is not found walking the left-hand history
653
is not found walking the left-hand history
742
655
br_revno, br_rev_id = branch.last_revision_info()
743
656
repo = branch.repository
744
graph = repo.get_graph()
745
657
if start_rev_id is None and end_rev_id is None:
746
658
cur_revno = br_revno
747
for revision_id in graph.iter_lefthand_ancestry(br_rev_id,
748
(_mod_revision.NULL_REVISION,)):
659
for revision_id in repo.iter_reverse_revision_history(br_rev_id):
749
660
yield revision_id, str(cur_revno), 0
752
663
if end_rev_id is None:
753
664
end_rev_id = br_rev_id
754
665
found_start = start_rev_id is None
755
for revision_id in graph.iter_lefthand_ancestry(end_rev_id,
756
(_mod_revision.NULL_REVISION,)):
757
revno_str = _compute_revno_str(branch, revision_id)
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)
758
669
if not found_start and revision_id == start_rev_id:
759
if not exclude_common_ancestry:
760
yield revision_id, revno_str, 0
670
yield revision_id, revno_str, 0
761
671
found_start = True
811
721
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)
814
743
def _rebase_merge_depth(view_revisions):
815
744
"""Adjust depths upwards so the top level is 0."""
816
745
# If either the first or last revision have a merge_depth of 0, we're done
860
789
return log_rev_iterator
863
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
792
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
864
793
"""Create a filtered iterator of log_rev_iterator matching on a regex.
866
795
:param branch: The branch being logged.
867
796
:param generate_delta: Whether to generate a delta for each revision.
868
:param match: A dictionary with properties as keys and lists of strings
869
as values. To match, a revision may match any of the supplied strings
870
within a single property but must match at least one string for each
797
:param search: A user text search string.
872
798
:param log_rev_iterator: An input iterator containing all revisions that
873
799
could be displayed, in lists.
874
800
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
878
804
return log_rev_iterator
879
searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
880
for (k,v) in match.iteritems()]
881
return _filter_re(searchRE, log_rev_iterator)
884
def _filter_re(searchRE, 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):
885
811
for revs in log_rev_iterator:
886
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
890
def _match_filter(searchRE, rev):
892
'message': (rev.message,),
893
'committer': (rev.committer,),
894
'author': (rev.get_apparent_authors()),
895
'bugs': list(rev.iter_bugs())
897
strings[''] = [item for inner_list in strings.itervalues()
898
for item in inner_list]
899
for (k,v) in searchRE:
900
if k in strings and not _match_any_filter(strings[k], v):
904
def _match_any_filter(strings, res):
905
return any([filter(None, map(re.search, strings)) for re in res])
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))
907
819
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
908
820
fileids=None, direction='reverse'):
1082
995
if branch_revno != 0:
1083
996
if (start_rev_id == _mod_revision.NULL_REVISION
1084
997
or end_rev_id == _mod_revision.NULL_REVISION):
1085
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
998
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1086
999
if start_revno > end_revno:
1087
raise errors.BzrCommandError(gettext("Start revision must be "
1088
"older than the end revision."))
1000
raise errors.BzrCommandError("Start revision must be older than "
1001
"the end revision.")
1089
1002
return (start_rev_id, end_rev_id)
1141
1054
if ((start_rev_id == _mod_revision.NULL_REVISION)
1142
1055
or (end_rev_id == _mod_revision.NULL_REVISION)):
1143
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1056
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1144
1057
if start_revno > end_revno:
1145
raise errors.BzrCommandError(gettext("Start revision must be older "
1146
"than the end revision."))
1058
raise errors.BzrCommandError("Start revision must be older than "
1059
"the end revision.")
1148
1061
if end_revno < start_revno:
1149
1062
return None, None, None, None
1150
1063
cur_revno = branch_revno
1152
1065
mainline_revs = []
1153
graph = branch.repository.get_graph()
1154
for revision_id in graph.iter_lefthand_ancestry(
1155
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1066
for revision_id in branch.repository.iter_reverse_revision_history(
1067
branch_last_revision):
1156
1068
if cur_revno < start_revno:
1157
1069
# We have gone far enough, but we always add 1 more revision
1158
1070
rev_nos[revision_id] = cur_revno
1172
1084
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
1175
1131
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1176
1132
include_merges=True):
1177
1133
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
1259
1254
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1260
1255
"""Reverse revisions by depth.
1298
1293
def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
1299
tags=None, diff=None, signature=None):
1294
tags=None, diff=None):
1304
self.revno = str(revno)
1296
self.revno = str(revno)
1305
1297
self.merge_depth = merge_depth
1306
1298
self.delta = delta
1307
1299
self.tags = tags
1308
1300
self.diff = diff
1309
self.signature = signature
1312
1303
class LogFormatter(object):
1321
1312
to indicate which LogRevision attributes it supports:
1323
1314
- supports_delta must be True if this log formatter supports delta.
1324
Otherwise the delta attribute may not be populated. The 'delta_format'
1325
attribute describes whether the 'short_status' format (1) or the long
1326
one (2) should be used.
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.
1328
1319
- supports_merge_revisions must be True if this log formatter supports
1329
merge revisions. If not, then only mainline revisions will be passed
1320
merge revisions. If not, then only mainline revisions will be passed
1332
1323
- preferred_levels is the number of levels this formatter defaults to.
1333
The default value is zero meaning display all levels.
1334
This value is only relevant if supports_merge_revisions is True.
1324
The default value is zero meaning display all levels.
1325
This value is only relevant if supports_merge_revisions is True.
1336
1327
- supports_tags must be True if this log formatter supports tags.
1337
Otherwise the tags attribute may not be populated.
1328
Otherwise the tags attribute may not be populated.
1339
1330
- supports_diff must be True if this log formatter supports diffs.
1340
Otherwise the diff attribute may not be populated.
1342
- supports_signatures must be True if this log formatter supports GPG
1331
Otherwise the diff attribute may not be populated.
1345
1333
Plugins can register functions to show custom revision properties using
1346
1334
the properties_handler_registry. The registered function
1347
must respect the following interface description::
1335
must respect the following interface description:
1349
1336
def my_show_properties(properties_dict):
1350
1337
# code that returns a dict {'name':'value'} of the properties
1355
1342
def __init__(self, to_file, show_ids=False, show_timezone='original',
1356
1343
delta_format=None, levels=None, show_advice=False,
1357
to_exact_file=None, author_list_handler=None):
1344
to_exact_file=None):
1358
1345
"""Create a LogFormatter.
1360
1347
:param to_file: the file to output to
1361
:param to_exact_file: if set, gives an output stream to which
1348
:param to_exact_file: if set, gives an output stream to which
1362
1349
non-Unicode diffs are written.
1363
1350
:param show_ids: if True, revision-ids are to be displayed
1364
1351
:param show_timezone: the timezone to use
1430
1414
def short_author(self, rev):
1431
return self.authors(rev, 'first', short=True, sep=', ')
1433
def authors(self, rev, who, short=False, sep=None):
1434
"""Generate list of authors, taking --authors option into account.
1436
The caller has to specify the name of a author list handler,
1437
as provided by the author list registry, using the ``who``
1438
argument. That name only sets a default, though: when the
1439
user selected a different author list generation using the
1440
``--authors`` command line switch, as represented by the
1441
``author_list_handler`` constructor argument, that value takes
1444
:param rev: The revision for which to generate the list of authors.
1445
:param who: Name of the default handler.
1446
:param short: Whether to shorten names to either name or address.
1447
:param sep: What separator to use for automatic concatenation.
1449
if self._author_list_handler is not None:
1450
# The user did specify --authors, which overrides the default
1451
author_list_handler = self._author_list_handler
1453
# The user didn't specify --authors, so we use the caller's default
1454
author_list_handler = author_list_registry.get(who)
1455
names = author_list_handler(rev)
1457
for i in range(len(names)):
1458
name, address = config.parse_username(names[i])
1464
names = sep.join(names)
1415
name, address = config.parse_username(rev.get_apparent_authors()[0])
1467
1420
def merge_marker(self, revision):
1468
1421
"""Get the merge marker to include in the output or '' if none."""
1564
1516
self.merge_marker(revision)))
1565
1517
if revision.tags:
1566
1518
lines.append('tags: %s' % (', '.join(revision.tags)))
1567
if self.show_ids or revision.revno is None:
1568
1520
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1570
1521
for parent_id in revision.rev.parent_ids:
1571
1522
lines.append('parent: %s' % (parent_id,))
1572
1523
lines.extend(self.custom_properties(revision.rev))
1574
1525
committer = revision.rev.committer
1575
authors = self.authors(revision.rev, 'all')
1526
authors = revision.rev.get_apparent_authors()
1576
1527
if authors != [committer]:
1577
1528
lines.append('author: %s' % (", ".join(authors),))
1578
1529
lines.append('committer: %s' % (committer,))
1600
1548
if revision.delta is not None:
1601
1549
# Use the standard status output to display changes
1602
1550
from bzrlib.delta import report_delta
1603
report_delta(to_file, revision.delta, short_status=False,
1551
report_delta(to_file, revision.delta, short_status=False,
1604
1552
show_ids=self.show_ids, indent=indent)
1605
1553
if revision.diff is not None:
1606
1554
to_file.write(indent + 'diff:\n')
1652
1600
if revision.tags:
1653
1601
tags = ' {%s}' % (', '.join(revision.tags))
1654
1602
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1655
revision.revno or "", self.short_author(revision.rev),
1603
revision.revno, self.short_author(revision.rev),
1656
1604
format_date(revision.rev.timestamp,
1657
1605
revision.rev.timezone or 0,
1658
1606
self.show_timezone, date_fmt="%Y-%m-%d",
1659
1607
show_offset=False),
1660
1608
tags, self.merge_marker(revision)))
1661
1609
self.show_properties(revision.rev, indent+offset)
1662
if self.show_ids or revision.revno is None:
1663
1611
to_file.write(indent + offset + 'revision-id:%s\n'
1664
1612
% (revision.rev.revision_id,))
1665
1613
if not revision.rev.message:
1672
1620
if revision.delta is not None:
1673
1621
# Use the standard status output to display changes
1674
1622
from bzrlib.delta import report_delta
1675
report_delta(to_file, revision.delta,
1676
short_status=self.delta_format==1,
1623
report_delta(to_file, revision.delta,
1624
short_status=self.delta_format==1,
1677
1625
show_ids=self.show_ids, indent=indent + offset)
1678
1626
if revision.diff is not None:
1679
1627
self.show_diff(self.to_exact_file, revision.diff, ' ')
1719
1667
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1720
1668
"""Format log info into one string. Truncate tail of string
1722
:param revno: revision number or None.
1723
Revision numbers counts from 1.
1724
:param rev: revision object
1725
:param max_chars: maximum length of resulting string
1726
:param tags: list of tags or None
1727
:param prefix: string to prefix each line
1728
:return: formatted truncated 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
1732
1679
# show revno only when is not None
1733
1680
out.append("%s:" % revno)
1734
if max_chars is not None:
1735
out.append(self.truncate(self.short_author(rev), (max_chars+3)/4))
1737
out.append(self.short_author(rev))
1681
out.append(self.truncate(self.short_author(rev), 20))
1738
1682
out.append(self.date_string(rev))
1739
1683
if len(rev.parent_ids) > 1:
1740
1684
out.append('[merge]')
1759
1703
self.show_timezone,
1760
1704
date_fmt='%Y-%m-%d',
1761
1705
show_offset=False)
1762
committer_str = self.authors(revision.rev, 'first', sep=', ')
1763
committer_str = committer_str.replace(' <', ' <')
1706
committer_str = revision.rev.get_apparent_authors()[0].replace (' <', ' <')
1764
1707
to_file.write('%s %s\n\n' % (date_str,committer_str))
1766
1709
if revision.delta is not None and revision.delta.has_changed():
1830
1772
return log_formatter_registry.make_formatter(name, *args, **kwargs)
1831
1773
except KeyError:
1832
raise errors.BzrCommandError(gettext("unknown log formatter: %r") % name)
1835
def author_list_all(rev):
1836
return rev.get_apparent_authors()[:]
1839
def author_list_first(rev):
1840
lst = rev.get_apparent_authors()
1847
def author_list_committer(rev):
1848
return [rev.committer]
1851
author_list_registry = registry.Registry()
1853
author_list_registry.register('all', author_list_all,
1856
author_list_registry.register('first', author_list_first,
1859
author_list_registry.register('committer', author_list_committer,
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)
1863
1783
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
2021
1940
:param file_list: the list of paths given on the command line;
2022
1941
the first of these can be a branch location or a file path,
2023
1942
the remainder must be file paths
2024
:param add_cleanup: When the branch returned is read locked,
2025
an unlock call will be queued to the cleanup.
2026
1943
:return: (branch, info_list, start_rev_info, end_rev_info) where
2027
1944
info_list is a list of (relative_path, file_id, kind) tuples where
2028
1945
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2029
1946
branch will be read-locked.
2031
from builtins import _get_revision_range
2032
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2034
add_cleanup(b.lock_read().unlock)
1948
from builtins import _get_revision_range, safe_relpath_files
1949
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2035
1951
# XXX: It's damn messy converting a list of paths to relative paths when
2036
1952
# those paths might be deleted ones, they might be on a case-insensitive
2037
1953
# filesystem and/or they might be in silly locations (like another branch).
added
removed
bzrlib/log.py
