53
from cStringIO import StringIO
54
from itertools import (
51
from io import BytesIO
60
55
from warnings import (
64
from bzrlib.lazy_import import lazy_import
59
from .lazy_import import lazy_import
65
60
lazy_import(globals(), """
73
repository as _mod_repository,
74
68
revision as _mod_revision,
70
from breezy.i18n import gettext, ngettext
84
from bzrlib.osutils import (
79
from .osutils import (
86
81
format_date_with_offset_in_original_timezone,
82
get_diff_header_encoding,
87
83
get_terminal_encoding,
91
from bzrlib.symbol_versioning import (
97
def find_touching_revisions(branch, file_id):
92
def find_touching_revisions(repository, last_revision, last_tree, last_path):
98
93
"""Yield a description of revisions which affect the file_id.
100
95
Each returned element is (revno, revision_id, description)
105
100
TODO: Perhaps some way to limit this to only particular revisions,
106
101
or to traverse a non-mainline set of revisions?
111
for revision_id in branch.revision_history():
112
this_inv = branch.repository.get_inventory(revision_id)
113
if file_id in this_inv:
114
this_ie = this_inv[file_id]
115
this_path = this_inv.id2path(file_id)
117
this_ie = this_path = None
103
last_verifier = last_tree.get_file_verifier(last_path)
104
graph = repository.get_graph()
105
history = list(graph.iter_lefthand_ancestry(last_revision, []))
107
for revision_id in history:
108
this_tree = repository.revision_tree(revision_id)
109
this_intertree = InterTree.get(this_tree, last_tree)
110
this_path = this_intertree.find_source_path(last_path)
119
112
# now we know how it was last time, and how it is in this revision.
120
113
# are those two states effectively the same or not?
122
if not this_ie and not last_ie:
123
# not present in either
125
elif this_ie and not last_ie:
126
yield revno, revision_id, "added " + this_path
127
elif not this_ie and last_ie:
129
yield revno, revision_id, "deleted " + last_path
114
if this_path is not None and last_path is None:
115
yield revno, revision_id, "deleted " + this_path
116
this_verifier = this_tree.get_file_verifier(this_path)
117
elif this_path is None and last_path is not None:
118
yield revno, revision_id, "added " + last_path
130
119
elif this_path != last_path:
131
yield revno, revision_id, ("renamed %s => %s" % (last_path, this_path))
132
elif (this_ie.text_size != last_ie.text_size
133
or this_ie.text_sha1 != last_ie.text_sha1):
134
yield revno, revision_id, "modified " + this_path
120
yield revno, revision_id, ("renamed %s => %s" % (this_path, last_path))
121
this_verifier = this_tree.get_file_verifier(this_path)
123
this_verifier = this_tree.get_file_verifier(this_path)
124
if (this_verifier != last_verifier):
125
yield revno, revision_id, "modified " + this_path
127
last_verifier = this_verifier
137
128
last_path = this_path
141
def _enumerate_history(branch):
144
for rev_id in branch.revision_history():
145
rh.append((revno, rev_id))
129
last_tree = this_tree
130
if last_path is None:
150
135
def show_log(branch,
152
specific_fileid=None,
154
138
direction='reverse',
155
139
start_revision=None,
156
140
end_revision=None,
160
145
"""Write out human-readable log of commits to this branch.
162
147
This function is being retained for backwards compatibility but
187
169
:param show_diff: If True, output a diff after each revision.
171
:param match: Dictionary of search lists to use when matching revision
189
# Convert old-style parameters to new-style parameters
190
if specific_fileid is not None:
191
file_ids = [specific_fileid]
196
delta_type = 'partial'
200
177
delta_type = None
203
diff_type = 'partial'
183
if isinstance(start_revision, int):
185
start_revision = revisionspec.RevisionInfo(branch, start_revision)
186
except (errors.NoSuchRevision, errors.RevnoOutOfBounds):
187
raise errors.InvalidRevisionNumber(start_revision)
189
if isinstance(end_revision, int):
191
end_revision = revisionspec.RevisionInfo(branch, end_revision)
192
except (errors.NoSuchRevision, errors.RevnoOutOfBounds):
193
raise errors.InvalidRevisionNumber(end_revision)
195
if end_revision is not None and end_revision.revno == 0:
196
raise errors.InvalidRevisionNumber(end_revision.revno)
209
198
# Build the request and execute it
210
rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
199
rqst = make_log_request_dict(
211
201
start_revision=start_revision, end_revision=end_revision,
212
202
limit=limit, message_search=search,
213
203
delta_type=delta_type, diff_type=diff_type)
214
204
Logger(branch, rqst).show(lf)
217
# Note: This needs to be kept this in sync with the defaults in
207
# Note: This needs to be kept in sync with the defaults in
218
208
# make_log_request_dict() below
219
209
_DEFAULT_REQUEST_PARAMS = {
220
210
'direction': 'reverse',
222
212
'generate_tags': True,
223
213
'exclude_common_ancestry': False,
224
214
'_match_using_deltas': True,
228
218
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
219
start_revision=None, end_revision=None, limit=None,
230
message_search=None, levels=1, generate_tags=True,
220
message_search=None, levels=None, generate_tags=True,
232
222
diff_type=None, _match_using_deltas=True,
233
exclude_common_ancestry=False,
223
exclude_common_ancestry=False, match=None,
224
signature=False, omit_merges=False,
235
226
"""Convenience function for making a logging request dictionary.
274
266
:param _match_using_deltas: a private parameter controlling the
275
267
algorithm used for matching specific_fileids. This parameter
276
may be removed in the future so bzrlib client code should NOT
268
may be removed in the future so breezy client code should NOT
279
271
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
272
range operator or as a graph difference.
274
:param signature: show digital signature information
276
:param match: Dictionary of list of search strings to use when filtering
277
revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
278
the empty string to match any of the preceding properties.
280
:param omit_merges: If True, commits with more than one parent are
284
# Take care of old style message_search parameter
287
if 'message' in match:
288
match['message'].append(message_search)
290
match['message'] = [message_search]
292
match = {'message': [message_search]}
283
294
'direction': direction,
284
295
'specific_fileids': specific_fileids,
285
296
'start_revision': start_revision,
286
297
'end_revision': end_revision,
288
'message_search': message_search,
289
299
'levels': levels,
290
300
'generate_tags': generate_tags,
291
301
'delta_type': delta_type,
292
302
'diff_type': diff_type,
293
303
'exclude_common_ancestry': exclude_common_ancestry,
304
'signature': signature,
306
'omit_merges': omit_merges,
294
307
# Add 'private' attributes for features that may be deprecated
295
308
'_match_using_deltas': _match_using_deltas,
299
312
def _apply_log_request_defaults(rqst):
300
313
"""Apply default values to a request dictionary."""
301
result = _DEFAULT_REQUEST_PARAMS
314
result = _DEFAULT_REQUEST_PARAMS.copy()
303
316
result.update(rqst)
320
def format_signature_validity(rev_id, branch):
321
"""get the signature validity
323
:param rev_id: revision id to validate
324
:param branch: branch of revision
325
:return: human readable string to print to log
327
from breezy import gpg
329
gpg_strategy = gpg.GPGStrategy(branch.get_config_stack())
330
result = branch.repository.verify_revision_signature(rev_id, gpg_strategy)
331
if result[0] == gpg.SIGNATURE_VALID:
332
return u"valid signature from {0}".format(result[1])
333
if result[0] == gpg.SIGNATURE_KEY_MISSING:
334
return "unknown key {0}".format(result[1])
335
if result[0] == gpg.SIGNATURE_NOT_VALID:
336
return "invalid signature!"
337
if result[0] == gpg.SIGNATURE_NOT_SIGNED:
338
return "no signature"
307
341
class LogGenerator(object):
308
342
"""A generator of log revisions."""
354
385
# Tweak the LogRequest based on what the LogFormatter can handle.
355
386
# (There's no point generating stuff if the formatter can't display it.)
357
rqst['levels'] = lf.get_levels()
388
if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
389
# user didn't specify levels, use whatever the LF can handle:
390
rqst['levels'] = lf.get_levels()
358
392
if not getattr(lf, 'supports_tags', False):
359
393
rqst['generate_tags'] = False
360
394
if not getattr(lf, 'supports_delta', False):
361
395
rqst['delta_type'] = None
362
396
if not getattr(lf, 'supports_diff', False):
363
397
rqst['diff_type'] = None
398
if not getattr(lf, 'supports_signatures', False):
399
rqst['signature'] = False
365
401
# Find and print the interesting revisions
366
402
generator = self._generator_factory(self.branch, rqst)
367
for lr in generator.iter_log_revisions():
404
for lr in generator.iter_log_revisions():
406
except errors.GhostRevisionUnusableHere:
407
raise errors.BzrCommandError(
408
gettext('Further revision history missing.'))
371
411
def _generator_factory(self, branch, rqst):
372
412
"""Make the LogGenerator object to use.
374
414
Subclasses may wish to override this.
376
416
return _DefaultLogGenerator(branch, rqst)
400
440
levels = rqst.get('levels')
401
441
limit = rqst.get('limit')
402
442
diff_type = rqst.get('diff_type')
443
show_signature = rqst.get('signature')
444
omit_merges = rqst.get('omit_merges')
404
446
revision_iterator = self._create_log_revision_iterator()
405
447
for revs in revision_iterator:
406
448
for (rev_id, revno, merge_depth), rev, delta in revs:
407
449
# 0 levels means show everything; merge_depth counts from 0
408
if levels != 0 and merge_depth >= levels:
450
if (levels != 0 and merge_depth is not None and
451
merge_depth >= levels):
453
if omit_merges and len(rev.parent_ids) > 1:
456
raise errors.GhostRevisionUnusableHere(rev_id)
410
457
if diff_type is None:
413
460
diff = self._format_diff(rev, rev_id, diff_type)
414
yield LogRevision(rev, revno, merge_depth, delta,
415
self.rev_tag_dict.get(rev_id), diff)
462
signature = format_signature_validity(rev_id, self.branch)
466
rev, revno, merge_depth, delta,
467
self.rev_tag_dict.get(rev_id), diff, signature)
418
470
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'),
476
file_ids=rqst.get('specific_fileids'),
477
direction=rqst.get('direction'))
529
rqst.get('delta_type'), rqst.get('match'),
530
file_ids=rqst.get('specific_fileids'),
531
direction=rqst.get('direction'))
479
533
def _log_revision_iterator_using_per_file_graph(self):
480
534
# Get the base revisions, filtering by the revision range.
488
542
if not isinstance(view_revisions, list):
489
543
view_revisions = list(view_revisions)
490
544
view_revisions = _filter_revisions_touching_file_id(self.branch,
491
rqst.get('specific_fileids')[0], view_revisions,
492
include_merges=rqst.get('levels') != 1)
545
rqst.get('specific_fileids')[
547
include_merges=rqst.get('levels') != 1)
493
548
return make_log_rev_iterator(self.branch, view_revisions,
494
rqst.get('delta_type'), rqst.get('message_search'))
549
rqst.get('delta_type'), rqst.get('match'))
497
552
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
560
a list of the same tuples.
507
562
if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
563
raise errors.BzrCommandError(gettext(
564
'--exclude-common-ancestry requires two different revisions'))
510
565
if direction not in ('reverse', 'forward'):
511
raise ValueError('invalid direction %r' % direction)
512
br_revno, br_rev_id = branch.last_revision_info()
566
raise ValueError(gettext('invalid direction %r') % direction)
567
br_rev_id = branch.last_revision()
568
if br_rev_id == _mod_revision.NULL_REVISION:
516
571
if (end_rev_id and start_rev_id == end_rev_id
517
572
and (not generate_merge_revisions
518
573
or not _has_merges(branch, end_rev_id))):
519
574
# 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,
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)))
575
return _generate_one_revision(branch, end_rev_id, br_rev_id,
577
if not generate_merge_revisions:
579
# If we only want to see linear revisions, we can iterate ...
580
iter_revs = _linear_view_revisions(
581
branch, start_rev_id, end_rev_id,
582
exclude_common_ancestry=exclude_common_ancestry)
583
# If a start limit was given and it's not obviously an
584
# ancestor of the end limit, check it before outputting anything
585
if (direction == 'forward'
586
or (start_rev_id and not _is_obvious_ancestor(
587
branch, start_rev_id, end_rev_id))):
588
iter_revs = list(iter_revs)
589
if direction == 'forward':
590
iter_revs = reversed(iter_revs)
592
except _StartNotLinearAncestor:
593
# Switch to the slower implementation that may be able to find a
594
# non-obvious ancestor out of the left-hand history.
596
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
597
direction, delayed_graph_generation,
598
exclude_common_ancestry)
599
if direction == 'forward':
600
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
540
607
return [(br_rev_id, br_revno, 0)]
542
revno = branch.revision_id_to_dotted_revno(rev_id)
543
revno_str = '.'.join(str(n) for n in revno)
609
revno_str = _compute_revno_str(branch, rev_id)
544
610
return [(rev_id, revno_str, 0)]
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)
549
# If a start limit was given and it's not obviously an
550
# ancestor of the end limit, check it before outputting anything
551
if direction == 'forward' or (start_rev_id
552
and not _is_obvious_ancestor(branch, start_rev_id, end_rev_id)):
554
result = list(result)
555
except _StartNotLinearAncestor:
556
raise errors.BzrCommandError('Start revision not found in'
557
' left-hand history of end revision.')
561
613
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
614
delayed_graph_generation,
563
615
exclude_common_ancestry=False):
571
623
initial_revisions = []
572
624
if delayed_graph_generation:
574
for rev_id, revno, depth in _linear_view_revisions(
575
branch, start_rev_id, end_rev_id):
626
for rev_id, revno, depth in _linear_view_revisions(
627
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
576
628
if _has_merges(branch, rev_id):
577
629
# The end_rev_id can be nested down somewhere. We need an
578
630
# explicit ancestry check. There is an ambiguity here as we
610
662
# shown naturally, i.e. just like it is for linear logging. We can easily
611
663
# make forward the exact opposite display, but showing the merge revisions
612
664
# indented at the end seems slightly nicer in that case.
613
view_revisions = chain(iter(initial_revisions),
614
_graph_view_revisions(branch, start_rev_id, end_rev_id,
615
rebase_initial_depths=(direction == 'reverse'),
616
exclude_common_ancestry=exclude_common_ancestry))
665
view_revisions = itertools.chain(iter(initial_revisions),
666
_graph_view_revisions(branch, start_rev_id, end_rev_id,
667
rebase_initial_depths=(
668
direction == 'reverse'),
669
exclude_common_ancestry=exclude_common_ancestry))
617
670
return view_revisions
623
676
return len(parents) > 1
679
def _compute_revno_str(branch, rev_id):
680
"""Compute the revno string from a rev_id.
682
:return: The revno string, or None if the revision is not in the supplied
686
revno = branch.revision_id_to_dotted_revno(rev_id)
687
except errors.NoSuchRevision:
688
# The revision must be outside of this branch
691
return '.'.join(str(n) for n in revno)
626
694
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
695
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
628
696
if start_rev_id and end_rev_id:
629
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
630
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
698
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
699
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
700
except errors.NoSuchRevision:
701
# one or both is not in the branch; not obvious
631
703
if len(start_dotted) == 1 and len(end_dotted) == 1:
632
704
# both on mainline
633
705
return start_dotted[0] <= end_dotted[0]
634
706
elif (len(start_dotted) == 3 and len(end_dotted) == 3 and
635
start_dotted[0:1] == end_dotted[0:1]):
707
start_dotted[0:1] == end_dotted[0:1]):
636
708
# both on same development line
637
709
return start_dotted[2] <= end_dotted[2]
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
718
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
719
exclude_common_ancestry=False):
647
720
"""Calculate a sequence of revisions to view, newest to oldest.
649
722
:param start_rev_id: the lower revision-id
650
723
:param end_rev_id: the upper revision-id
724
:param exclude_common_ancestry: Whether the start_rev_id should be part of
725
the iterated revisions.
651
726
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
727
dotted_revno will be None for ghosts
652
728
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
is not found walking the left-hand history
729
is not found walking the left-hand history
655
br_revno, br_rev_id = branch.last_revision_info()
656
731
repo = branch.repository
732
graph = repo.get_graph()
657
733
if start_rev_id is None and end_rev_id is None:
659
for revision_id in repo.iter_reverse_revision_history(br_rev_id):
660
yield revision_id, str(cur_revno), 0
734
if branch._format.stores_revno() or \
735
config.GlobalStack().get('calculate_revnos'):
737
br_revno, br_rev_id = branch.last_revision_info()
738
except errors.GhostRevisionsHaveNoRevno:
739
br_rev_id = branch.last_revision()
744
br_rev_id = branch.last_revision()
747
graph_iter = graph.iter_lefthand_ancestry(br_rev_id,
748
(_mod_revision.NULL_REVISION,))
751
revision_id = next(graph_iter)
752
except errors.RevisionNotPresent as e:
754
yield e.revision_id, None, None
756
except StopIteration:
759
yield revision_id, str(cur_revno) if cur_revno is not None else None, 0
760
if cur_revno is not None:
763
br_rev_id = branch.last_revision()
663
764
if end_rev_id is None:
664
765
end_rev_id = br_rev_id
665
766
found_start = start_rev_id is None
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)
669
if not found_start and revision_id == start_rev_id:
670
yield revision_id, revno_str, 0
767
graph_iter = graph.iter_lefthand_ancestry(end_rev_id,
768
(_mod_revision.NULL_REVISION,))
771
revision_id = next(graph_iter)
772
except StopIteration:
774
except errors.RevisionNotPresent as e:
776
yield e.revision_id, None, None
674
yield revision_id, revno_str, 0
677
raise _StartNotLinearAncestor()
779
revno_str = _compute_revno_str(branch, revision_id)
780
if not found_start and revision_id == start_rev_id:
781
if not exclude_common_ancestry:
782
yield revision_id, revno_str, 0
786
yield revision_id, revno_str, 0
788
raise _StartNotLinearAncestor()
680
791
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
721
832
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)
743
835
def _rebase_merge_depth(view_revisions):
744
836
"""Adjust depths upwards so the top level is 0."""
745
837
# If either the first or last revision have a merge_depth of 0, we're done
746
838
if view_revisions and view_revisions[0][2] and view_revisions[-1][2]:
747
min_depth = min([d for r,n,d in view_revisions])
839
min_depth = min([d for r, n, d in view_revisions])
748
840
if min_depth != 0:
749
view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
841
view_revisions = [(r, n, d - min_depth)
842
for r, n, d in view_revisions]
750
843
return view_revisions
753
846
def make_log_rev_iterator(branch, view_revisions, generate_delta, search,
754
file_ids=None, direction='reverse'):
847
file_ids=None, direction='reverse'):
755
848
"""Create a revision iterator for log.
757
850
:param branch: The branch being logged.
768
861
# Convert view_revisions into (view, None, None) groups to fit with
769
862
# the standard interface here.
770
if type(view_revisions) == list:
863
if isinstance(view_revisions, list):
771
864
# A single batch conversion is faster than many incremental ones.
772
865
# As we have all the data, do a batch conversion.
773
866
nones = [None] * len(view_revisions)
774
log_rev_iterator = iter([zip(view_revisions, nones, nones)])
867
log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
777
870
for view in view_revisions:
781
874
# It would be nicer if log adapters were first class objects
782
875
# with custom parameters. This will do for now. IGC 20090127
783
876
if adapter == _make_delta_filter:
784
log_rev_iterator = adapter(branch, generate_delta,
785
search, log_rev_iterator, file_ids, direction)
877
log_rev_iterator = adapter(
878
branch, generate_delta, search, log_rev_iterator, file_ids,
787
log_rev_iterator = adapter(branch, generate_delta,
788
search, log_rev_iterator)
881
log_rev_iterator = adapter(
882
branch, generate_delta, search, log_rev_iterator)
789
883
return log_rev_iterator
792
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
886
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
887
"""Create a filtered iterator of log_rev_iterator matching on a regex.
795
889
:param branch: The branch being logged.
796
890
:param generate_delta: Whether to generate a delta for each revision.
797
:param search: A user text search string.
891
:param match: A dictionary with properties as keys and lists of strings
892
as values. To match, a revision may match any of the supplied strings
893
within a single property but must match at least one string for each
798
895
:param log_rev_iterator: An input iterator containing all revisions that
799
896
could be displayed, in lists.
800
897
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
804
901
return 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):
902
# Use lazy_compile so mapping to InvalidPattern error occurs.
903
searchRE = [(k, [lazy_regex.lazy_compile(x, re.IGNORECASE) for x in v])
904
for k, v in match.items()]
905
return _filter_re(searchRE, log_rev_iterator)
908
def _filter_re(searchRE, log_rev_iterator):
811
909
for revs in log_rev_iterator:
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))
910
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
915
def _match_filter(searchRE, rev):
917
'message': (rev.message,),
918
'committer': (rev.committer,),
919
'author': (rev.get_apparent_authors()),
920
'bugs': list(rev.iter_bugs())
922
strings[''] = [item for inner_list in strings.values()
923
for item in inner_list]
924
for k, v in searchRE:
925
if k in strings and not _match_any_filter(strings[k], v):
930
def _match_any_filter(strings, res):
931
return any(r.search(s) for r in res for s in strings)
819
934
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
fileids=None, direction='reverse'):
935
fileids=None, direction='reverse'):
821
936
"""Add revision deltas to a log iterator if needed.
823
938
:param branch: The branch being logged.
866
981
if delta_type == 'full' and not check_fileids:
867
982
deltas = repository.get_deltas_for_revisions(revisions)
868
for rev, delta in izip(revs, deltas):
983
for rev, delta in zip(revs, deltas):
869
984
new_revs.append((rev[0], rev[1], delta))
871
986
deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
872
for rev, delta in izip(revs, deltas):
987
for rev, delta in zip(revs, deltas):
873
988
if check_fileids:
874
989
if delta is None or not delta.has_changed():
894
1009
def _update_fileids(delta, fileids, stop_on):
895
1010
"""Update the set of file-ids to search based on file lifecycle events.
897
1012
:param fileids: a set of fileids to update
898
1013
:param stop_on: either 'add' or 'remove' - take file-ids out of the
899
1014
fileids set once their add or remove entry is detected respectively
901
1016
if stop_on == 'add':
902
for item in delta.added:
903
if item[1] in fileids:
904
fileids.remove(item[1])
1017
for item in delta.added + delta.copied:
1018
if item.file_id in fileids:
1019
fileids.remove(item.file_id)
905
1020
elif stop_on == 'delete':
906
1021
for item in delta.removed:
907
if item[1] in fileids:
908
fileids.remove(item[1])
1022
if item.file_id in fileids:
1023
fileids.remove(item.file_id)
911
1026
def _make_revision_objects(branch, generate_delta, search, log_rev_iterator):
923
1038
for revs in log_rev_iterator:
924
1039
# r = revision_id, n = revno, d = merge depth
925
1040
revision_ids = [view[0] for view, _, _ in revs]
926
revisions = repository.get_revisions(revision_ids)
927
revs = [(rev[0], revision, rev[2]) for rev, revision in
928
izip(revs, revisions)]
1041
revisions = dict(repository.iter_revisions(revision_ids))
1042
yield [(rev[0], revisions[rev[0][0]], rev[2]) for rev in revs]
932
1045
def _make_batch_filter(branch, generate_delta, search, log_rev_iterator):
968
1079
:return: (start_rev_id, end_rev_id) tuple.
970
branch_revno, branch_rev_id = branch.last_revision_info()
971
1081
start_rev_id = None
972
if start_revision is None:
1083
if start_revision is not None:
1084
if not isinstance(start_revision, revisionspec.RevisionInfo):
1085
raise TypeError(start_revision)
1086
start_rev_id = start_revision.rev_id
1087
start_revno = start_revision.revno
1088
if start_revno is None:
975
if isinstance(start_revision, revisionspec.RevisionInfo):
976
start_rev_id = start_revision.rev_id
977
start_revno = start_revision.revno or 1
979
branch.check_real_revno(start_revision)
980
start_revno = start_revision
981
start_rev_id = branch.get_rev_id(start_revno)
983
1091
end_rev_id = None
984
if end_revision is None:
985
end_revno = branch_revno
987
if isinstance(end_revision, revisionspec.RevisionInfo):
988
end_rev_id = end_revision.rev_id
989
end_revno = end_revision.revno or branch_revno
991
branch.check_real_revno(end_revision)
992
end_revno = end_revision
993
end_rev_id = branch.get_rev_id(end_revno)
1093
if end_revision is not None:
1094
if not isinstance(end_revision, revisionspec.RevisionInfo):
1095
raise TypeError(start_revision)
1096
end_rev_id = end_revision.rev_id
1097
end_revno = end_revision.revno
995
if branch_revno != 0:
1099
if branch.last_revision() != _mod_revision.NULL_REVISION:
996
1100
if (start_rev_id == _mod_revision.NULL_REVISION
997
or end_rev_id == _mod_revision.NULL_REVISION):
998
raise errors.BzrCommandError('Logging revision 0 is invalid.')
999
if start_revno > end_revno:
1000
raise errors.BzrCommandError("Start revision must be older than "
1001
"the end revision.")
1101
or end_rev_id == _mod_revision.NULL_REVISION):
1102
raise errors.BzrCommandError(
1103
gettext('Logging revision 0 is invalid.'))
1104
if end_revno is not None and start_revno > end_revno:
1105
raise errors.BzrCommandError(
1106
gettext("Start revision must be older than the end revision."))
1002
1107
return (start_rev_id, end_rev_id)
1052
1157
end_revno = end_revision
1054
1159
if ((start_rev_id == _mod_revision.NULL_REVISION)
1055
or (end_rev_id == _mod_revision.NULL_REVISION)):
1056
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1160
or (end_rev_id == _mod_revision.NULL_REVISION)):
1161
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1057
1162
if start_revno > end_revno:
1058
raise errors.BzrCommandError("Start revision must be older than "
1059
"the end revision.")
1163
raise errors.BzrCommandError(gettext("Start revision must be older "
1164
"than the end revision."))
1061
1166
if end_revno < start_revno:
1062
1167
return None, None, None, None
1063
1168
cur_revno = branch_revno
1065
1170
mainline_revs = []
1066
for revision_id in branch.repository.iter_reverse_revision_history(
1067
branch_last_revision):
1171
graph = branch.repository.get_graph()
1172
for revision_id in graph.iter_lefthand_ancestry(
1173
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1068
1174
if cur_revno < start_revno:
1069
1175
# We have gone far enough, but we always add 1 more revision
1070
1176
rev_nos[revision_id] = cur_revno
1084
1190
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
1131
1193
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
include_merges=True):
1194
include_merges=True):
1133
1195
r"""Return the list of revision ids which touch a given file id.
1135
1197
The function filters view_revisions and returns a subset.
1136
1198
This includes the revisions which directly change the file id,
1137
1199
and the revisions which merge these changes. So if the
1138
1200
revision graph is::
1177
1242
# indexing layer. We might consider passing in hints as to the known
1178
1243
# access pattern (sparse/clustered, high success rate/low success
1179
1244
# rate). This particular access is clustered with a low success rate.
1180
get_parent_map = branch.repository.texts.get_parent_map
1181
1245
modified_text_revisions = set()
1182
1246
chunk_size = 1000
1183
for start in xrange(0, len(text_keys), chunk_size):
1247
for start in range(0, len(text_keys), chunk_size):
1184
1248
next_keys = text_keys[start:start + chunk_size]
1185
1249
# Only keep the revision_id portion of the key
1186
1250
modified_text_revisions.update(
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
1254
1277
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1278
"""Reverse revisions by depth.
1257
1280
Revisions with a different depth are sorted as a group with the previous
1258
revision of that depth. There may be no topological justification for this,
1281
revision of that depth. There may be no topological justification for this
1259
1282
but it looks much nicer.
1261
1284
# Add a fake revision at start so that we can always attach sub revisions
1312
1339
to indicate which LogRevision attributes it supports:
1314
1341
- supports_delta must be True if this log formatter supports delta.
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.
1342
Otherwise the delta attribute may not be populated. The 'delta_format'
1343
attribute describes whether the 'short_status' format (1) or the long
1344
one (2) should be used.
1319
1346
- supports_merge_revisions must be True if this log formatter supports
1320
merge revisions. If not, then only mainline revisions will be passed
1347
merge revisions. If not, then only mainline revisions will be passed
1323
1350
- preferred_levels is the number of levels this formatter defaults to.
1324
The default value is zero meaning display all levels.
1325
This value is only relevant if supports_merge_revisions is True.
1351
The default value is zero meaning display all levels.
1352
This value is only relevant if supports_merge_revisions is True.
1327
1354
- supports_tags must be True if this log formatter supports tags.
1328
Otherwise the tags attribute may not be populated.
1355
Otherwise the tags attribute may not be populated.
1330
1357
- supports_diff must be True if this log formatter supports diffs.
1331
Otherwise the diff attribute may not be populated.
1358
Otherwise the diff attribute may not be populated.
1360
- supports_signatures must be True if this log formatter supports GPG
1333
1363
Plugins can register functions to show custom revision properties using
1334
1364
the properties_handler_registry. The registered function
1335
must respect the following interface description:
1365
must respect the following interface description::
1336
1367
def my_show_properties(properties_dict):
1337
1368
# code that returns a dict {'name':'value'} of the properties
1361
1392
self.to_file = to_file
1362
1393
# 'exact' stream used to show diff, it should print content 'as is'
1363
# and should not try to decode/encode it to unicode to avoid bug #328007
1394
# and should not try to decode/encode it to unicode to avoid bug
1364
1396
if to_exact_file is not None:
1365
1397
self.to_exact_file = to_exact_file
1367
# XXX: somewhat hacky; this assumes it's a codec writer; it's better
1368
# for code that expects to get diffs to pass in the exact file
1399
# XXX: somewhat hacky; this assumes it's a codec writer; it's
1400
# better for code that expects to get diffs to pass in the exact
1370
1402
self.to_exact_file = getattr(to_file, 'stream', to_file)
1371
1403
self.show_ids = show_ids
1372
1404
self.show_timezone = show_timezone
1373
1405
if delta_format is None:
1374
1406
# Ensures backward compatibility
1375
delta_format = 2 # long format
1407
delta_format = 2 # long format
1376
1408
self.delta_format = delta_format
1377
1409
self.levels = levels
1378
1410
self._show_advice = show_advice
1547
1585
lines = [_LONG_SEP]
1548
1586
if revision.revno is not None:
1549
1587
lines.append('revno: %s%s' % (revision.revno,
1550
self.merge_marker(revision)))
1588
self.merge_marker(revision)))
1551
1589
if revision.tags:
1552
lines.append('tags: %s' % (', '.join(revision.tags)))
1590
lines.append('tags: %s' % (', '.join(sorted(revision.tags))))
1591
if self.show_ids or revision.revno is None:
1592
lines.append('revision-id: %s' %
1593
(revision.rev.revision_id.decode('utf-8'),))
1553
1594
if self.show_ids:
1554
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1555
1595
for parent_id in revision.rev.parent_ids:
1556
lines.append('parent: %s' % (parent_id,))
1596
lines.append('parent: %s' % (parent_id.decode('utf-8'),))
1557
1597
lines.extend(self.custom_properties(revision.rev))
1559
1599
committer = revision.rev.committer
1581
1624
to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1582
1625
if revision.delta is not None:
1583
1626
# Use the standard status output to display changes
1584
from bzrlib.delta import report_delta
1585
report_delta(to_file, revision.delta, short_status=False,
1627
from breezy.delta import report_delta
1628
report_delta(to_file, revision.delta, short_status=False,
1586
1629
show_ids=self.show_ids, indent=indent)
1587
1630
if revision.diff is not None:
1588
1631
to_file.write(indent + 'diff:\n')
1632
1675
to_file = self.to_file
1634
1677
if revision.tags:
1635
tags = ' {%s}' % (', '.join(revision.tags))
1678
tags = ' {%s}' % (', '.join(sorted(revision.tags)))
1636
1679
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1637
revision.revno, self.short_author(revision.rev),
1638
format_date(revision.rev.timestamp,
1639
revision.rev.timezone or 0,
1640
self.show_timezone, date_fmt="%Y-%m-%d",
1642
tags, self.merge_marker(revision)))
1643
self.show_properties(revision.rev, indent+offset)
1680
revision.revno or "", self.short_author(
1682
format_date(revision.rev.timestamp,
1683
revision.rev.timezone or 0,
1684
self.show_timezone, date_fmt="%Y-%m-%d",
1686
tags, self.merge_marker(revision)))
1687
self.show_properties(revision.rev, indent + offset)
1688
if self.show_ids or revision.revno is None:
1645
1689
to_file.write(indent + offset + 'revision-id:%s\n'
1646
% (revision.rev.revision_id,))
1690
% (revision.rev.revision_id.decode('utf-8'),))
1647
1691
if not revision.rev.message:
1648
1692
to_file.write(indent + offset + '(no message)\n')
1654
1698
if revision.delta is not None:
1655
1699
# Use the standard status output to display changes
1656
from bzrlib.delta import report_delta
1657
report_delta(to_file, revision.delta,
1658
short_status=self.delta_format==1,
1700
from breezy.delta import report_delta
1701
report_delta(to_file, revision.delta,
1702
short_status=self.delta_format == 1,
1659
1703
show_ids=self.show_ids, indent=indent + offset)
1660
1704
if revision.diff is not None:
1661
1705
self.show_diff(self.to_exact_file, revision.diff, ' ')
1695
1739
def log_revision(self, revision):
1696
1740
indent = ' ' * revision.merge_depth
1697
1741
self.to_file.write(self.log_string(revision.revno, revision.rev,
1698
self._max_chars, revision.tags, indent))
1742
self._max_chars, revision.tags, indent))
1699
1743
self.to_file.write('\n')
1701
1745
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1702
1746
"""Format log info into one string. Truncate tail of string
1703
:param revno: revision number or None.
1704
Revision numbers counts from 1.
1705
:param rev: revision object
1706
:param max_chars: maximum length of resulting string
1707
:param tags: list of tags or None
1708
:param prefix: string to prefix each line
1709
:return: formatted truncated string
1748
:param revno: revision number or None.
1749
Revision numbers counts from 1.
1750
:param rev: revision object
1751
:param max_chars: maximum length of resulting string
1752
:param tags: list of tags or None
1753
:param prefix: string to prefix each line
1754
:return: formatted truncated string
1713
1758
# show revno only when is not None
1714
1759
out.append("%s:" % revno)
1715
out.append(self.truncate(self.short_author(rev), 20))
1760
if max_chars is not None:
1761
out.append(self.truncate(
1762
self.short_author(rev), (max_chars + 3) // 4))
1764
out.append(self.short_author(rev))
1716
1765
out.append(self.date_string(rev))
1717
1766
if len(rev.parent_ids) > 1:
1718
1767
out.append('[merge]')
1720
tag_str = '{%s}' % (', '.join(tags))
1769
tag_str = '{%s}' % (', '.join(sorted(tags)))
1721
1770
out.append(tag_str)
1722
1771
out.append(rev.get_summary())
1723
1772
return self.truncate(prefix + " ".join(out).rstrip('\n'), max_chars)
1739
1788
show_offset=False)
1740
1789
committer_str = self.authors(revision.rev, 'first', sep=', ')
1741
1790
committer_str = committer_str.replace(' <', ' <')
1742
to_file.write('%s %s\n\n' % (date_str,committer_str))
1791
to_file.write('%s %s\n\n' % (date_str, committer_str))
1744
1793
if revision.delta is not None and revision.delta.has_changed():
1745
1794
for c in revision.delta.added + revision.delta.removed + revision.delta.modified:
1795
if c.path[0] is None:
1747
1799
to_file.write('\t* %s:\n' % (path,))
1748
for c in revision.delta.renamed:
1749
oldpath,newpath = c[:2]
1800
for c in revision.delta.renamed + revision.delta.copied:
1750
1801
# For renamed files, show both the old and the new path
1751
to_file.write('\t* %s:\n\t* %s:\n' % (oldpath,newpath))
1802
to_file.write('\t* %s:\n\t* %s:\n' % (c.path[0], c.path[1]))
1752
1803
to_file.write('\n')
1754
1805
if not revision.rev.message:
1777
1828
return self.get(name)(*args, **kwargs)
1779
1830
def get_default(self, branch):
1780
return self.get(branch.get_config().log_format())
1831
c = branch.get_config_stack()
1832
return self.get(c.get('log_format'))
1783
1835
log_formatter_registry = LogFormatterRegistry()
1786
1838
log_formatter_registry.register('short', ShortLogFormatter,
1787
'Moderately short log format')
1839
'Moderately short log format.')
1788
1840
log_formatter_registry.register('long', LongLogFormatter,
1789
'Detailed log format')
1841
'Detailed log format.')
1790
1842
log_formatter_registry.register('line', LineLogFormatter,
1791
'Log format with one line per revision')
1843
'Log format with one line per revision.')
1792
1844
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1793
'Format used by GNU ChangeLog files')
1845
'Format used by GNU ChangeLog files.')
1796
1848
def register_formatter(name, formatter):
1863
1910
# This is the first index which is different between
1865
1912
base_idx = None
1866
for i in xrange(max(len(new_rh),
1913
for i in range(max(len(new_rh), len(old_rh))):
1868
1914
if (len(new_rh) <= i
1869
1915
or len(old_rh) <= i
1870
or new_rh[i] != old_rh[i]):
1916
or new_rh[i] != old_rh[i]):
1874
1920
if base_idx is None:
1875
1921
to_file.write('Nothing seems to have changed\n')
1877
## TODO: It might be nice to do something like show_log
1878
## and show the merged entries. But since this is the
1879
## removed revisions, it shouldn't be as important
1923
# TODO: It might be nice to do something like show_log
1924
# and show the merged entries. But since this is the
1925
# removed revisions, it shouldn't be as important
1880
1926
if base_idx < len(old_rh):
1881
to_file.write('*'*60)
1927
to_file.write('*' * 60)
1882
1928
to_file.write('\nRemoved Revisions:\n')
1883
1929
for i in range(base_idx, len(old_rh)):
1884
1930
rev = branch.repository.get_revision(old_rh[i])
1885
lr = LogRevision(rev, i+1, 0, None)
1931
lr = LogRevision(rev, i + 1, 0, None)
1886
1932
lf.log_revision(lr)
1887
to_file.write('*'*60)
1933
to_file.write('*' * 60)
1888
1934
to_file.write('\n\n')
1889
1935
if base_idx < len(new_rh):
1890
1936
to_file.write('Added Revisions:\n')
1891
1937
show_log(branch,
1895
1940
direction='forward',
1896
start_revision=base_idx+1,
1941
start_revision=base_idx + 1,
1897
1942
end_revision=len(new_rh),
1966
2012
log_format = log_formatter_registry.get_default(branch)
1967
2013
lf = log_format(show_ids=False, to_file=output, show_timezone='original')
1968
2014
if old_history != []:
1969
output.write('*'*60)
2015
output.write('*' * 60)
1970
2016
output.write('\nRemoved Revisions:\n')
1971
2017
show_flat_log(branch.repository, old_history, old_revno, lf)
1972
output.write('*'*60)
2018
output.write('*' * 60)
1973
2019
output.write('\n\n')
1974
2020
if new_history != []:
1975
2021
output.write('Added Revisions:\n')
1976
2022
start_revno = new_revno - len(new_history) + 1
1977
show_log(branch, lf, None, verbose=False, direction='forward',
1978
start_revision=start_revno,)
2023
show_log(branch, lf, verbose=False, direction='forward',
2024
start_revision=start_revno)
1981
2027
def show_flat_log(repository, history, last_revno, lf):
1986
2032
:param last_revno: The revno of the last revision_id in the history.
1987
2033
:param lf: The log formatter to use.
1989
start_revno = last_revno - len(history) + 1
1990
2035
revisions = repository.get_revisions(history)
1991
2036
for i, rev in enumerate(revisions):
1992
2037
lr = LogRevision(rev, i + last_revno, 0, None)
1993
2038
lf.log_revision(lr)
1996
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
2041
def _get_info_for_log_files(revisionspec_list, file_list, exit_stack):
1997
2042
"""Find file-ids and kinds given a list of files and a revision range.
1999
2044
We search for files at the end of the range. If not found there,
2003
2048
:param file_list: the list of paths given on the command line;
2004
2049
the first of these can be a branch location or a file path,
2005
2050
the remainder must be file paths
2006
:param add_cleanup: When the branch returned is read locked,
2007
an unlock call will be queued to the cleanup.
2051
:param exit_stack: When the branch returned is read locked,
2052
an unlock call will be queued to the exit stack.
2008
2053
:return: (branch, info_list, start_rev_info, end_rev_info) where
2009
2054
info_list is a list of (relative_path, file_id, kind) tuples where
2010
2055
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2011
2056
branch will be read-locked.
2013
from builtins import _get_revision_range, safe_relpath_files
2014
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2015
add_cleanup(b.lock_read().unlock)
2058
from breezy.builtins import _get_revision_range
2059
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2061
exit_stack.enter_context(b.lock_read())
2016
2062
# XXX: It's damn messy converting a list of paths to relative paths when
2017
2063
# those paths might be deleted ones, they might be on a case-insensitive
2018
2064
# filesystem and/or they might be in silly locations (like another branch).
2022
2068
# case of running log in a nested directory, assuming paths beyond the
2023
2069
# first one haven't been deleted ...
2025
relpaths = [path] + safe_relpath_files(tree, file_list[1:])
2071
relpaths = [path] + tree.safe_relpath_files(file_list[1:])
2027
2073
relpaths = [path] + file_list[1:]
2029
2075
start_rev_info, end_rev_info = _get_revision_range(revisionspec_list, b,
2031
2077
if relpaths in ([], [u'']):
2032
2078
return b, [], start_rev_info, end_rev_info
2033
2079
if start_rev_info is None and end_rev_info is None:
2083
2129
tree1 = b.repository.revision_tree(rev_id)
2084
2130
file_id = tree1.path2id(fp)
2085
kind = _get_kind_for_file_id(tree1, file_id)
2131
kind = _get_kind_for_file_id(tree1, fp, file_id)
2086
2132
info_list.append((fp, file_id, kind))
2087
2133
return b, info_list, start_rev_info, end_rev_info
2090
def _get_kind_for_file_id(tree, file_id):
2136
def _get_kind_for_file_id(tree, path, file_id):
2091
2137
"""Return the kind of a file-id or None if it doesn't exist."""
2092
2138
if file_id is not None:
2093
return tree.kind(file_id)
2139
return tree.kind(path)
2098
2144
properties_handler_registry = registry.Registry()
2100
2146
# Use the properties handlers to print out bug information if available
2101
2149
def _bugs_properties_handler(revision):
2102
if revision.properties.has_key('bugs'):
2103
bug_lines = revision.properties['bugs'].split('\n')
2104
bug_rows = [line.split(' ', 1) for line in bug_lines]
2105
fixed_bug_urls = [row[0] for row in bug_rows if
2106
len(row) > 1 and row[1] == 'fixed']
2151
related_bug_urls = []
2152
for bug_url, status in revision.iter_bugs():
2153
if status == 'fixed':
2154
fixed_bug_urls.append(bug_url)
2155
elif status == 'related':
2156
related_bug_urls.append(bug_url)
2159
text = ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls))
2160
ret[text] = ' '.join(fixed_bug_urls)
2161
if related_bug_urls:
2162
text = ngettext('related bug', 'related bugs',
2163
len(related_bug_urls))
2164
ret[text] = ' '.join(related_bug_urls)
2109
return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2112
2168
properties_handler_registry.register('bugs_properties_handler',
2113
2169
_bugs_properties_handler)
added
removed
breezy/log.py
