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
209
Logger(branch, rqst).show(lf)
216
# 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
217
213
# make_log_request_dict() below
218
214
_DEFAULT_REQUEST_PARAMS = {
219
215
'direction': 'reverse',
221
217
'generate_tags': True,
222
218
'exclude_common_ancestry': False,
223
219
'_match_using_deltas': True,
227
223
def make_log_request_dict(direction='reverse', specific_fileids=None,
228
224
start_revision=None, end_revision=None, limit=None,
229
message_search=None, levels=1, generate_tags=True,
225
message_search=None, levels=None, generate_tags=True,
231
227
diff_type=None, _match_using_deltas=True,
232
exclude_common_ancestry=False,
228
exclude_common_ancestry=False, match=None,
229
signature=False, omit_merges=False,
234
231
"""Convenience function for making a logging request dictionary.
256
253
matching commit messages
258
255
:param levels: the number of levels of revisions to
259
generate; 1 for just the mainline; 0 for all levels.
256
generate; 1 for just the mainline; 0 for all levels, or None for
261
259
:param generate_tags: If True, include tags for matched revisions.
263
261
:param delta_type: Either 'full', 'partial' or None.
264
262
'full' means generate the complete delta - adds/deletes/modifies/etc;
265
263
'partial' means filter the delta using specific_fileids;
278
276
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
279
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] }
282
299
'direction': direction,
283
300
'specific_fileids': specific_fileids,
284
301
'start_revision': start_revision,
285
302
'end_revision': end_revision,
287
'message_search': message_search,
288
304
'levels': levels,
289
305
'generate_tags': generate_tags,
290
306
'delta_type': delta_type,
291
307
'diff_type': diff_type,
292
308
'exclude_common_ancestry': exclude_common_ancestry,
309
'signature': signature,
311
'omit_merges': omit_merges,
293
312
# Add 'private' attributes for features that may be deprecated
294
313
'_match_using_deltas': _match_using_deltas,
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 "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"
306
346
class LogGenerator(object):
307
347
"""A generator of log revisions."""
353
393
# Tweak the LogRequest based on what the LogFormatter can handle.
354
394
# (There's no point generating stuff if the formatter can't display it.)
356
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()
357
400
if not getattr(lf, 'supports_tags', False):
358
401
rqst['generate_tags'] = False
359
402
if not getattr(lf, 'supports_delta', False):
360
403
rqst['delta_type'] = None
361
404
if not getattr(lf, 'supports_diff', False):
362
405
rqst['diff_type'] = None
406
if not getattr(lf, 'supports_signatures', False):
407
rqst['signature'] = False
364
409
# Find and print the interesting revisions
365
410
generator = self._generator_factory(self.branch, rqst)
406
453
# 0 levels means show everything; merge_depth counts from 0
407
454
if levels != 0 and merge_depth >= levels:
456
if omit_merges and len(rev.parent_ids) > 1:
409
458
if diff_type is None:
412
461
diff = self._format_diff(rev, rev_id, diff_type)
463
signature = format_signature_validity(rev_id,
464
self.branch.repository)
413
467
yield LogRevision(rev, revno, merge_depth, delta,
414
self.rev_tag_dict.get(rev_id), diff)
468
self.rev_tag_dict.get(rev_id), diff, signature)
417
471
if log_count >= limit:
473
527
# Apply the other filters
474
528
return make_log_rev_iterator(self.branch, view_revisions,
475
rqst.get('delta_type'), rqst.get('message_search'),
529
rqst.get('delta_type'), rqst.get('match'),
476
530
file_ids=rqst.get('specific_fileids'),
477
531
direction=rqst.get('direction'))
491
545
rqst.get('specific_fileids')[0], view_revisions,
492
546
include_merges=rqst.get('levels') != 1)
493
547
return make_log_rev_iterator(self.branch, view_revisions,
494
rqst.get('delta_type'), rqst.get('message_search'))
548
rqst.get('delta_type'), rqst.get('match'))
497
551
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
559
a list of the same tuples.
507
561
if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
562
raise errors.BzrCommandError(gettext(
563
'--exclude-common-ancestry requires two different revisions'))
510
564
if direction not in ('reverse', 'forward'):
511
raise ValueError('invalid direction %r' % direction)
565
raise ValueError(gettext('invalid direction %r') % direction)
512
566
br_revno, br_rev_id = branch.last_revision_info()
513
567
if br_revno == 0:
517
571
and (not generate_merge_revisions
518
572
or not _has_merges(branch, end_rev_id))):
519
573
# 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)))
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)))
543
609
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
612
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
564
613
delayed_graph_generation,
565
614
exclude_common_ancestry=False):
601
650
except _StartNotLinearAncestor:
602
651
# A merge was never detected so the lower revision limit can't
603
652
# be nested down somewhere
604
raise errors.BzrCommandError('Start revision not found in'
605
' history of end revision.')
653
raise errors.BzrCommandError(gettext('Start revision not found in'
654
' history of end revision.'))
607
656
# We exit the loop above because we encounter a revision with merges, from
608
657
# this revision, we need to switch to _graph_view_revisions.
679
728
br_revno, br_rev_id = branch.last_revision_info()
680
729
repo = branch.repository
730
graph = repo.get_graph()
681
731
if start_rev_id is None and end_rev_id is None:
682
732
cur_revno = br_revno
683
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,)):
684
735
yield revision_id, str(cur_revno), 0
687
738
if end_rev_id is None:
688
739
end_rev_id = br_rev_id
689
740
found_start = start_rev_id is None
690
for revision_id in repo.iter_reverse_revision_history(end_rev_id):
741
for revision_id in graph.iter_lefthand_ancestry(end_rev_id,
742
(_mod_revision.NULL_REVISION,)):
691
743
revno_str = _compute_revno_str(branch, revision_id)
692
744
if not found_start and revision_id == start_rev_id:
693
745
if not exclude_common_ancestry:
745
797
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
800
def _rebase_merge_depth(view_revisions):
768
801
"""Adjust depths upwards so the top level is 0."""
769
802
# If either the first or last revision have a merge_depth of 0, we're done
813
846
return log_rev_iterator
816
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
849
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
817
850
"""Create a filtered iterator of log_rev_iterator matching on a regex.
819
852
:param branch: The branch being logged.
820
853
:param generate_delta: Whether to generate a delta for each revision.
821
: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
822
858
:param log_rev_iterator: An input iterator containing all revisions that
823
859
could be displayed, in lists.
824
860
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
828
864
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):
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):
834
871
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))
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])
842
893
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
843
894
fileids=None, direction='reverse'):
1018
1068
if branch_revno != 0:
1019
1069
if (start_rev_id == _mod_revision.NULL_REVISION
1020
1070
or end_rev_id == _mod_revision.NULL_REVISION):
1021
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1071
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1022
1072
if start_revno > end_revno:
1023
raise errors.BzrCommandError("Start revision must be older than "
1024
"the end revision.")
1073
raise errors.BzrCommandError(gettext("Start revision must be "
1074
"older than the end revision."))
1025
1075
return (start_rev_id, end_rev_id)
1077
1127
if ((start_rev_id == _mod_revision.NULL_REVISION)
1078
1128
or (end_rev_id == _mod_revision.NULL_REVISION)):
1079
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1129
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1080
1130
if start_revno > end_revno:
1081
raise errors.BzrCommandError("Start revision must be older than "
1082
"the end revision.")
1131
raise errors.BzrCommandError(gettext("Start revision must be older "
1132
"than the end revision."))
1084
1134
if end_revno < start_revno:
1085
1135
return None, None, None, None
1086
1136
cur_revno = branch_revno
1088
1138
mainline_revs = []
1089
for revision_id in branch.repository.iter_reverse_revision_history(
1090
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,)):
1091
1142
if cur_revno < start_revno:
1092
1143
# We have gone far enough, but we always add 1 more revision
1093
1144
rev_nos[revision_id] = cur_revno
1107
1158
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
1161
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1155
1162
include_merges=True):
1156
1163
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
1245
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1280
1246
"""Reverse revisions by depth.
1374
1344
"""Create a LogFormatter.
1376
1346
:param to_file: the file to output to
1377
: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
1378
1348
non-Unicode diffs are written.
1379
1349
:param show_ids: if True, revision-ids are to be displayed
1380
1350
:param show_timezone: the timezone to use
1612
1586
if revision.delta is not None:
1613
1587
# Use the standard status output to display changes
1614
1588
from bzrlib.delta import report_delta
1615
report_delta(to_file, revision.delta, short_status=False,
1589
report_delta(to_file, revision.delta, short_status=False,
1616
1590
show_ids=self.show_ids, indent=indent)
1617
1591
if revision.diff is not None:
1618
1592
to_file.write(indent + 'diff:\n')
1684
1658
if revision.delta is not None:
1685
1659
# Use the standard status output to display changes
1686
1660
from bzrlib.delta import report_delta
1687
report_delta(to_file, revision.delta,
1688
short_status=self.delta_format==1,
1661
report_delta(to_file, revision.delta,
1662
short_status=self.delta_format==1,
1689
1663
show_ids=self.show_ids, indent=indent + offset)
1690
1664
if revision.diff is not None:
1691
1665
self.show_diff(self.to_exact_file, revision.diff, ' ')
1811
1785
return self.get(name)(*args, **kwargs)
1813
1787
def get_default(self, branch):
1814
return self.get(branch.get_config().log_format())
1788
c = branch.get_config_stack()
1789
return self.get(c.get('log_format'))
1817
1792
log_formatter_registry = LogFormatterRegistry()
1820
1795
log_formatter_registry.register('short', ShortLogFormatter,
1821
'Moderately short log format')
1796
'Moderately short log format.')
1822
1797
log_formatter_registry.register('long', LongLogFormatter,
1823
'Detailed log format')
1798
'Detailed log format.')
1824
1799
log_formatter_registry.register('line', LineLogFormatter,
1825
'Log format with one line per revision')
1800
'Log format with one line per revision.')
1826
1801
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1827
'Format used by GNU ChangeLog files')
1802
'Format used by GNU ChangeLog files.')
1830
1805
def register_formatter(name, formatter):
1871
1846
'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
1849
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1881
1850
log_format='long'):
1882
1851
"""Show the change in revision history comparing the old revision history to the new one.
2044
2014
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2045
2015
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])
2017
from bzrlib.builtins import _get_revision_range
2018
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2049
2020
add_cleanup(b.lock_read().unlock)
2050
2021
# XXX: It's damn messy converting a list of paths to relative paths when
2051
2022
# those paths might be deleted ones, they might be on a case-insensitive
added
removed
bzrlib/log.py
