110
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):
111
112
this_inv = branch.repository.get_inventory(revision_id)
112
if file_id in this_inv:
113
if this_inv.has_id(file_id):
113
114
this_ie = this_inv[file_id]
114
115
this_path = this_inv.id2path(file_id)
213
218
Logger(branch, rqst).show(lf)
216
# 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
217
222
# make_log_request_dict() below
218
223
_DEFAULT_REQUEST_PARAMS = {
219
224
'direction': 'reverse',
221
226
'generate_tags': True,
222
227
'exclude_common_ancestry': False,
223
228
'_match_using_deltas': True,
227
232
def make_log_request_dict(direction='reverse', specific_fileids=None,
228
233
start_revision=None, end_revision=None, limit=None,
229
message_search=None, levels=1, generate_tags=True,
234
message_search=None, levels=None, generate_tags=True,
231
236
diff_type=None, _match_using_deltas=True,
232
exclude_common_ancestry=False,
237
exclude_common_ancestry=False, match=None,
238
signature=False, omit_merges=False,
234
240
"""Convenience function for making a logging request dictionary.
256
262
matching commit messages
258
264
:param levels: the number of levels of revisions to
259
generate; 1 for just the mainline; 0 for all levels.
265
generate; 1 for just the mainline; 0 for all levels, or None for
261
268
:param generate_tags: If True, include tags for matched revisions.
263
270
:param delta_type: Either 'full', 'partial' or None.
264
271
'full' means generate the complete delta - adds/deletes/modifies/etc;
265
272
'partial' means filter the delta using specific_fileids;
278
285
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
279
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] }
282
308
'direction': direction,
283
309
'specific_fileids': specific_fileids,
284
310
'start_revision': start_revision,
285
311
'end_revision': end_revision,
287
'message_search': message_search,
288
313
'levels': levels,
289
314
'generate_tags': generate_tags,
290
315
'delta_type': delta_type,
291
316
'diff_type': diff_type,
292
317
'exclude_common_ancestry': exclude_common_ancestry,
318
'signature': signature,
320
'omit_merges': omit_merges,
293
321
# Add 'private' attributes for features that may be deprecated
294
322
'_match_using_deltas': _match_using_deltas,
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"
306
355
class LogGenerator(object):
307
356
"""A generator of log revisions."""
353
402
# Tweak the LogRequest based on what the LogFormatter can handle.
354
403
# (There's no point generating stuff if the formatter can't display it.)
356
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()
357
409
if not getattr(lf, 'supports_tags', False):
358
410
rqst['generate_tags'] = False
359
411
if not getattr(lf, 'supports_delta', False):
360
412
rqst['delta_type'] = None
361
413
if not getattr(lf, 'supports_diff', False):
362
414
rqst['diff_type'] = None
415
if not getattr(lf, 'supports_signatures', False):
416
rqst['signature'] = False
364
418
# Find and print the interesting revisions
365
419
generator = self._generator_factory(self.branch, rqst)
406
462
# 0 levels means show everything; merge_depth counts from 0
407
463
if levels != 0 and merge_depth >= levels:
465
if omit_merges and len(rev.parent_ids) > 1:
409
467
if diff_type is None:
412
470
diff = self._format_diff(rev, rev_id, diff_type)
472
signature = format_signature_validity(rev_id,
473
self.branch.repository)
413
476
yield LogRevision(rev, revno, merge_depth, delta,
414
self.rev_tag_dict.get(rev_id), diff)
477
self.rev_tag_dict.get(rev_id), diff, signature)
417
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,
525
direction, exclude_common_ancestry)
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)))
543
618
return [(rev_id, revno_str, 0)]
546
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction,
547
exclude_common_ancestry=False):
548
result = _linear_view_revisions(
549
branch, start_rev_id, end_rev_id,
550
exclude_common_ancestry=exclude_common_ancestry)
551
# If a start limit was given and it's not obviously an
552
# ancestor of the end limit, check it before outputting anything
553
if direction == 'forward' or (start_rev_id
554
and not _is_obvious_ancestor(branch, start_rev_id, end_rev_id)):
556
result = list(result)
557
except _StartNotLinearAncestor:
558
raise errors.BzrCommandError('Start revision not found in'
559
' left-hand history of end revision.')
563
621
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
564
622
delayed_graph_generation,
565
623
exclude_common_ancestry=False):
601
659
except _StartNotLinearAncestor:
602
660
# A merge was never detected so the lower revision limit can't
603
661
# be nested down somewhere
604
raise errors.BzrCommandError('Start revision not found in'
605
' history of end revision.')
662
raise errors.BzrCommandError(gettext('Start revision not found in'
663
' history of end revision.'))
607
665
# We exit the loop above because we encounter a revision with merges, from
608
666
# this revision, we need to switch to _graph_view_revisions.
679
737
br_revno, br_rev_id = branch.last_revision_info()
680
738
repo = branch.repository
739
graph = repo.get_graph()
681
740
if start_rev_id is None and end_rev_id is None:
682
741
cur_revno = br_revno
683
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,)):
684
744
yield revision_id, str(cur_revno), 0
687
747
if end_rev_id is None:
688
748
end_rev_id = br_rev_id
689
749
found_start = start_rev_id is None
690
for revision_id in repo.iter_reverse_revision_history(end_rev_id):
750
for revision_id in graph.iter_lefthand_ancestry(end_rev_id,
751
(_mod_revision.NULL_REVISION,)):
691
752
revno_str = _compute_revno_str(branch, revision_id)
692
753
if not found_start and revision_id == start_rev_id:
693
754
if not exclude_common_ancestry:
745
806
yield rev_id, '.'.join(map(str, revno)), merge_depth
748
@deprecated_function(deprecated_in((2, 2, 0)))
749
def calculate_view_revisions(branch, start_revision, end_revision, direction,
750
specific_fileid, generate_merge_revisions):
751
"""Calculate the revisions to view.
753
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
754
a list of the same tuples.
756
start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
758
view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,
759
direction, generate_merge_revisions or specific_fileid))
761
view_revisions = _filter_revisions_touching_file_id(branch,
762
specific_fileid, view_revisions,
763
include_merges=generate_merge_revisions)
764
return _rebase_merge_depth(view_revisions)
767
809
def _rebase_merge_depth(view_revisions):
768
810
"""Adjust depths upwards so the top level is 0."""
769
811
# If either the first or last revision have a merge_depth of 0, we're done
813
855
return log_rev_iterator
816
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
858
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
817
859
"""Create a filtered iterator of log_rev_iterator matching on a regex.
819
861
:param branch: The branch being logged.
820
862
:param generate_delta: Whether to generate a delta for each revision.
821
: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
822
867
:param log_rev_iterator: An input iterator containing all revisions that
823
868
could be displayed, in lists.
824
869
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
828
873
return log_rev_iterator
829
searchRE = re.compile(search, re.IGNORECASE)
830
return _filter_message_re(searchRE, log_rev_iterator)
833
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):
834
880
for revs in log_rev_iterator:
836
for (rev_id, revno, merge_depth), rev, delta in revs:
837
if searchRE.search(rev.message):
838
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])
842
902
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
843
903
fileids=None, direction='reverse'):
1018
1077
if branch_revno != 0:
1019
1078
if (start_rev_id == _mod_revision.NULL_REVISION
1020
1079
or end_rev_id == _mod_revision.NULL_REVISION):
1021
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1080
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1022
1081
if start_revno > end_revno:
1023
raise errors.BzrCommandError("Start revision must be older than "
1024
"the end revision.")
1082
raise errors.BzrCommandError(gettext("Start revision must be "
1083
"older than the end revision."))
1025
1084
return (start_rev_id, end_rev_id)
1077
1136
if ((start_rev_id == _mod_revision.NULL_REVISION)
1078
1137
or (end_rev_id == _mod_revision.NULL_REVISION)):
1079
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1138
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1080
1139
if start_revno > end_revno:
1081
raise errors.BzrCommandError("Start revision must be older than "
1082
"the end revision.")
1140
raise errors.BzrCommandError(gettext("Start revision must be older "
1141
"than the end revision."))
1084
1143
if end_revno < start_revno:
1085
1144
return None, None, None, None
1086
1145
cur_revno = branch_revno
1088
1147
mainline_revs = []
1089
for revision_id in branch.repository.iter_reverse_revision_history(
1090
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,)):
1091
1151
if cur_revno < start_revno:
1092
1152
# We have gone far enough, but we always add 1 more revision
1093
1153
rev_nos[revision_id] = cur_revno
1107
1167
return mainline_revs, rev_nos, start_rev_id, end_rev_id
1110
@deprecated_function(deprecated_in((2, 2, 0)))
1111
def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):
1112
"""Filter view_revisions based on revision ranges.
1114
:param view_revisions: A list of (revision_id, dotted_revno, merge_depth)
1115
tuples to be filtered.
1117
:param start_rev_id: If not NONE specifies the first revision to be logged.
1118
If NONE then all revisions up to the end_rev_id are logged.
1120
:param end_rev_id: If not NONE specifies the last revision to be logged.
1121
If NONE then all revisions up to the end of the log are logged.
1123
:return: The filtered view_revisions.
1125
if start_rev_id or end_rev_id:
1126
revision_ids = [r for r, n, d in view_revisions]
1128
start_index = revision_ids.index(start_rev_id)
1131
if start_rev_id == end_rev_id:
1132
end_index = start_index
1135
end_index = revision_ids.index(end_rev_id)
1137
end_index = len(view_revisions) - 1
1138
# To include the revisions merged into the last revision,
1139
# extend end_rev_id down to, but not including, the next rev
1140
# with the same or lesser merge_depth
1141
end_merge_depth = view_revisions[end_index][2]
1143
for index in xrange(end_index+1, len(view_revisions)+1):
1144
if view_revisions[index][2] <= end_merge_depth:
1145
end_index = index - 1
1148
# if the search falls off the end then log to the end as well
1149
end_index = len(view_revisions) - 1
1150
view_revisions = view_revisions[start_index:end_index+1]
1151
return view_revisions
1154
1170
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1155
1171
include_merges=True):
1156
1172
r"""Return the list of revision ids which touch a given file id.
1238
@deprecated_function(deprecated_in((2, 2, 0)))
1239
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
1240
include_merges=True):
1241
"""Produce an iterator of revisions to show
1242
:return: an iterator of (revision_id, revno, merge_depth)
1243
(if there is no revno for a revision, None is supplied)
1245
if not include_merges:
1246
revision_ids = mainline_revs[1:]
1247
if direction == 'reverse':
1248
revision_ids.reverse()
1249
for revision_id in revision_ids:
1250
yield revision_id, str(rev_nos[revision_id]), 0
1252
graph = branch.repository.get_graph()
1253
# This asks for all mainline revisions, which means we only have to spider
1254
# sideways, rather than depth history. That said, its still size-of-history
1255
# and should be addressed.
1256
# mainline_revisions always includes an extra revision at the beginning, so
1258
parent_map = dict(((key, value) for key, value in
1259
graph.iter_ancestry(mainline_revs[1:]) if value is not None))
1260
# filter out ghosts; merge_sort errors on ghosts.
1261
rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
1262
merge_sorted_revisions = tsort.merge_sort(
1266
generate_revno=True)
1268
if direction == 'forward':
1269
# forward means oldest first.
1270
merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
1271
elif direction != 'reverse':
1272
raise ValueError('invalid direction %r' % direction)
1274
for (sequence, rev_id, merge_depth, revno, end_of_merge
1275
) in merge_sorted_revisions:
1276
yield rev_id, '.'.join(map(str, revno)), merge_depth
1279
1254
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1280
1255
"""Reverse revisions by depth.
1374
1353
"""Create a LogFormatter.
1376
1355
:param to_file: the file to output to
1377
: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
1378
1357
non-Unicode diffs are written.
1379
1358
:param show_ids: if True, revision-ids are to be displayed
1380
1359
:param show_timezone: the timezone to use
1612
1595
if revision.delta is not None:
1613
1596
# Use the standard status output to display changes
1614
1597
from bzrlib.delta import report_delta
1615
report_delta(to_file, revision.delta, short_status=False,
1598
report_delta(to_file, revision.delta, short_status=False,
1616
1599
show_ids=self.show_ids, indent=indent)
1617
1600
if revision.diff is not None:
1618
1601
to_file.write(indent + 'diff:\n')
1684
1667
if revision.delta is not None:
1685
1668
# Use the standard status output to display changes
1686
1669
from bzrlib.delta import report_delta
1687
report_delta(to_file, revision.delta,
1688
short_status=self.delta_format==1,
1670
report_delta(to_file, revision.delta,
1671
short_status=self.delta_format==1,
1689
1672
show_ids=self.show_ids, indent=indent + offset)
1690
1673
if revision.diff is not None:
1691
1674
self.show_diff(self.to_exact_file, revision.diff, ' ')
1811
1794
return self.get(name)(*args, **kwargs)
1813
1796
def get_default(self, branch):
1814
return self.get(branch.get_config().log_format())
1797
c = branch.get_config_stack()
1798
return self.get(c.get('log_format'))
1817
1801
log_formatter_registry = LogFormatterRegistry()
1820
1804
log_formatter_registry.register('short', ShortLogFormatter,
1821
'Moderately short log format')
1805
'Moderately short log format.')
1822
1806
log_formatter_registry.register('long', LongLogFormatter,
1823
'Detailed log format')
1807
'Detailed log format.')
1824
1808
log_formatter_registry.register('line', LineLogFormatter,
1825
'Log format with one line per revision')
1809
'Log format with one line per revision.')
1826
1810
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1827
'Format used by GNU ChangeLog files')
1811
'Format used by GNU ChangeLog files.')
1830
1814
def register_formatter(name, formatter):
1871
1855
'The committer')
1874
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1875
# deprecated; for compatibility
1876
lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
1877
lf.show(revno, rev, delta)
1880
1858
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1881
1859
log_format='long'):
1882
1860
"""Show the change in revision history comparing the old revision history to the new one.
2044
2023
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2045
2024
branch will be read-locked.
2047
from builtins import _get_revision_range
2048
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(
2049
2029
add_cleanup(b.lock_read().unlock)
2050
2030
# XXX: It's damn messy converting a list of paths to relative paths when
2051
2031
# those paths might be deleted ones, they might be on a case-insensitive
added
removed
bzrlib/log.py
