49
47
all the changes since the previous revision that touched hello.c.
50
from __future__ import absolute_import
53
from cStringIO import StringIO
54
from itertools import (
60
56
from warnings import (
64
from bzrlib.lazy_import import lazy_import
60
from .lazy_import import lazy_import
65
61
lazy_import(globals(), """
73
repository as _mod_repository,
74
69
revision as _mod_revision,
71
from breezy.i18n import gettext, ngettext
84
from bzrlib.osutils import (
80
from .osutils import (
86
82
format_date_with_offset_in_original_timezone,
83
get_diff_header_encoding,
87
84
get_terminal_encoding,
91
from bzrlib.symbol_versioning import (
97
def find_touching_revisions(branch, file_id):
92
from .tree import find_previous_path
95
def find_touching_revisions(repository, last_revision, last_tree, last_path):
98
96
"""Yield a description of revisions which affect the file_id.
100
98
Each returned element is (revno, revision_id, description)
105
103
TODO: Perhaps some way to limit this to only particular revisions,
106
104
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
106
last_verifier = last_tree.get_file_verifier(last_path)
107
graph = repository.get_graph()
108
history = list(graph.iter_lefthand_ancestry(last_revision, []))
110
for revision_id in history:
111
this_tree = repository.revision_tree(revision_id)
112
this_path = find_previous_path(last_tree, this_tree, last_path)
119
114
# now we know how it was last time, and how it is in this revision.
120
115
# 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
116
if this_path is not None and last_path is None:
117
yield revno, revision_id, "deleted " + this_path
118
this_verifier = this_tree.get_file_verifier(this_path)
119
elif this_path is None and last_path is not None:
120
yield revno, revision_id, "added " + last_path
130
121
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
122
yield revno, revision_id, ("renamed %s => %s" % (this_path, last_path))
123
this_verifier = this_tree.get_file_verifier(this_path)
125
this_verifier = this_tree.get_file_verifier(this_path)
126
if (this_verifier != last_verifier):
127
yield revno, revision_id, "modified " + this_path
129
last_verifier = this_verifier
137
130
last_path = this_path
141
def _enumerate_history(branch):
144
for rev_id in branch.revision_history():
145
rh.append((revno, rev_id))
131
last_tree = this_tree
132
if last_path is None:
150
137
def show_log(branch,
152
specific_fileid=None,
154
140
direction='reverse',
155
141
start_revision=None,
156
142
end_revision=None,
160
147
"""Write out human-readable log of commits to this branch.
162
149
This function is being retained for backwards compatibility but
187
171
:param show_diff: If True, output a diff after each revision.
173
: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
179
delta_type = None
203
diff_type = 'partial'
185
if isinstance(start_revision, int):
187
start_revision = revisionspec.RevisionInfo(branch, start_revision)
188
except (errors.NoSuchRevision, errors.RevnoOutOfBounds):
189
raise errors.InvalidRevisionNumber(start_revision)
191
if isinstance(end_revision, int):
193
end_revision = revisionspec.RevisionInfo(branch, end_revision)
194
except (errors.NoSuchRevision, errors.RevnoOutOfBounds):
195
raise errors.InvalidRevisionNumber(end_revision)
197
if end_revision is not None and end_revision.revno == 0:
198
raise errors.InvalidRevisionNumber(end_revision.revno)
209
200
# Build the request and execute it
210
rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
201
rqst = make_log_request_dict(
211
203
start_revision=start_revision, end_revision=end_revision,
212
204
limit=limit, message_search=search,
213
205
delta_type=delta_type, diff_type=diff_type)
214
206
Logger(branch, rqst).show(lf)
217
# Note: This needs to be kept this in sync with the defaults in
209
# Note: This needs to be kept in sync with the defaults in
218
210
# make_log_request_dict() below
219
211
_DEFAULT_REQUEST_PARAMS = {
220
212
'direction': 'reverse',
222
214
'generate_tags': True,
223
215
'exclude_common_ancestry': False,
224
216
'_match_using_deltas': True,
228
220
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
221
start_revision=None, end_revision=None, limit=None,
230
message_search=None, levels=1, generate_tags=True,
222
message_search=None, levels=None, generate_tags=True,
232
224
diff_type=None, _match_using_deltas=True,
233
exclude_common_ancestry=False,
225
exclude_common_ancestry=False, match=None,
226
signature=False, omit_merges=False,
235
228
"""Convenience function for making a logging request dictionary.
274
268
:param _match_using_deltas: a private parameter controlling the
275
269
algorithm used for matching specific_fileids. This parameter
276
may be removed in the future so bzrlib client code should NOT
270
may be removed in the future so breezy client code should NOT
279
273
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
274
range operator or as a graph difference.
276
:param signature: show digital signature information
278
:param match: Dictionary of list of search strings to use when filtering
279
revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
280
the empty string to match any of the preceding properties.
282
:param omit_merges: If True, commits with more than one parent are
286
# Take care of old style message_search parameter
289
if 'message' in match:
290
match['message'].append(message_search)
292
match['message'] = [message_search]
294
match = {'message': [message_search]}
283
296
'direction': direction,
284
297
'specific_fileids': specific_fileids,
285
298
'start_revision': start_revision,
286
299
'end_revision': end_revision,
288
'message_search': message_search,
289
301
'levels': levels,
290
302
'generate_tags': generate_tags,
291
303
'delta_type': delta_type,
292
304
'diff_type': diff_type,
293
305
'exclude_common_ancestry': exclude_common_ancestry,
306
'signature': signature,
308
'omit_merges': omit_merges,
294
309
# Add 'private' attributes for features that may be deprecated
295
310
'_match_using_deltas': _match_using_deltas,
299
314
def _apply_log_request_defaults(rqst):
300
315
"""Apply default values to a request dictionary."""
301
result = _DEFAULT_REQUEST_PARAMS
316
result = _DEFAULT_REQUEST_PARAMS.copy()
303
318
result.update(rqst)
322
def format_signature_validity(rev_id, branch):
323
"""get the signature validity
325
:param rev_id: revision id to validate
326
:param branch: branch of revision
327
:return: human readable string to print to log
329
from breezy import gpg
331
gpg_strategy = gpg.GPGStrategy(branch.get_config_stack())
332
result = branch.repository.verify_revision_signature(rev_id, gpg_strategy)
333
if result[0] == gpg.SIGNATURE_VALID:
334
return u"valid signature from {0}".format(result[1])
335
if result[0] == gpg.SIGNATURE_KEY_MISSING:
336
return "unknown key {0}".format(result[1])
337
if result[0] == gpg.SIGNATURE_NOT_VALID:
338
return "invalid signature!"
339
if result[0] == gpg.SIGNATURE_NOT_SIGNED:
340
return "no signature"
307
343
class LogGenerator(object):
308
344
"""A generator of log revisions."""
354
387
# Tweak the LogRequest based on what the LogFormatter can handle.
355
388
# (There's no point generating stuff if the formatter can't display it.)
357
rqst['levels'] = lf.get_levels()
390
if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
391
# user didn't specify levels, use whatever the LF can handle:
392
rqst['levels'] = lf.get_levels()
358
394
if not getattr(lf, 'supports_tags', False):
359
395
rqst['generate_tags'] = False
360
396
if not getattr(lf, 'supports_delta', False):
361
397
rqst['delta_type'] = None
362
398
if not getattr(lf, 'supports_diff', False):
363
399
rqst['diff_type'] = None
400
if not getattr(lf, 'supports_signatures', False):
401
rqst['signature'] = False
365
403
# Find and print the interesting revisions
366
404
generator = self._generator_factory(self.branch, rqst)
367
for lr in generator.iter_log_revisions():
406
for lr in generator.iter_log_revisions():
408
except errors.GhostRevisionUnusableHere:
409
raise errors.BzrCommandError(
410
gettext('Further revision history missing.'))
371
413
def _generator_factory(self, branch, rqst):
372
414
"""Make the LogGenerator object to use.
374
416
Subclasses may wish to override this.
376
418
return _DefaultLogGenerator(branch, rqst)
400
442
levels = rqst.get('levels')
401
443
limit = rqst.get('limit')
402
444
diff_type = rqst.get('diff_type')
445
show_signature = rqst.get('signature')
446
omit_merges = rqst.get('omit_merges')
404
448
revision_iterator = self._create_log_revision_iterator()
405
449
for revs in revision_iterator:
406
450
for (rev_id, revno, merge_depth), rev, delta in revs:
407
451
# 0 levels means show everything; merge_depth counts from 0
408
if levels != 0 and merge_depth >= levels:
452
if (levels != 0 and merge_depth is not None and
453
merge_depth >= levels):
455
if omit_merges and len(rev.parent_ids) > 1:
458
raise errors.GhostRevisionUnusableHere(rev_id)
410
459
if diff_type is None:
413
462
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)
464
signature = format_signature_validity(rev_id, self.branch)
468
rev, revno, merge_depth, delta,
469
self.rev_tag_dict.get(rev_id), diff, signature)
418
472
if log_count >= limit:
473
529
# Apply the other filters
474
530
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'))
531
rqst.get('delta_type'), rqst.get('match'),
532
file_ids=rqst.get('specific_fileids'),
533
direction=rqst.get('direction'))
479
535
def _log_revision_iterator_using_per_file_graph(self):
480
536
# Get the base revisions, filtering by the revision range.
488
544
if not isinstance(view_revisions, list):
489
545
view_revisions = list(view_revisions)
490
546
view_revisions = _filter_revisions_touching_file_id(self.branch,
491
rqst.get('specific_fileids')[0], view_revisions,
492
include_merges=rqst.get('levels') != 1)
547
rqst.get('specific_fileids')[
549
include_merges=rqst.get('levels') != 1)
493
550
return make_log_rev_iterator(self.branch, view_revisions,
494
rqst.get('delta_type'), rqst.get('message_search'))
551
rqst.get('delta_type'), rqst.get('match'))
497
554
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
562
a list of the same tuples.
507
564
if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
565
raise errors.BzrCommandError(gettext(
566
'--exclude-common-ancestry requires two different revisions'))
510
567
if direction not in ('reverse', 'forward'):
511
raise ValueError('invalid direction %r' % direction)
512
br_revno, br_rev_id = branch.last_revision_info()
568
raise ValueError(gettext('invalid direction %r') % direction)
569
br_rev_id = branch.last_revision()
570
if br_rev_id == _mod_revision.NULL_REVISION:
516
573
if (end_rev_id and start_rev_id == end_rev_id
517
574
and (not generate_merge_revisions
518
575
or not _has_merges(branch, end_rev_id))):
519
576
# 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)))
577
return _generate_one_revision(branch, end_rev_id, br_rev_id,
579
if not generate_merge_revisions:
581
# If we only want to see linear revisions, we can iterate ...
582
iter_revs = _linear_view_revisions(
583
branch, start_rev_id, end_rev_id,
584
exclude_common_ancestry=exclude_common_ancestry)
585
# If a start limit was given and it's not obviously an
586
# ancestor of the end limit, check it before outputting anything
587
if (direction == 'forward'
588
or (start_rev_id and not _is_obvious_ancestor(
589
branch, start_rev_id, end_rev_id))):
590
iter_revs = list(iter_revs)
591
if direction == 'forward':
592
iter_revs = reversed(iter_revs)
594
except _StartNotLinearAncestor:
595
# Switch to the slower implementation that may be able to find a
596
# non-obvious ancestor out of the left-hand history.
598
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
599
direction, delayed_graph_generation,
600
exclude_common_ancestry)
601
if direction == 'forward':
602
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
540
609
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)
611
revno_str = _compute_revno_str(branch, rev_id)
544
612
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
615
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
616
delayed_graph_generation,
563
617
exclude_common_ancestry=False):
571
625
initial_revisions = []
572
626
if delayed_graph_generation:
574
for rev_id, revno, depth in _linear_view_revisions(
575
branch, start_rev_id, end_rev_id):
628
for rev_id, revno, depth in _linear_view_revisions(
629
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
576
630
if _has_merges(branch, rev_id):
577
631
# The end_rev_id can be nested down somewhere. We need an
578
632
# explicit ancestry check. There is an ambiguity here as we
610
664
# shown naturally, i.e. just like it is for linear logging. We can easily
611
665
# make forward the exact opposite display, but showing the merge revisions
612
666
# 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))
667
view_revisions = itertools.chain(iter(initial_revisions),
668
_graph_view_revisions(branch, start_rev_id, end_rev_id,
669
rebase_initial_depths=(
670
direction == 'reverse'),
671
exclude_common_ancestry=exclude_common_ancestry))
617
672
return view_revisions
623
678
return len(parents) > 1
681
def _compute_revno_str(branch, rev_id):
682
"""Compute the revno string from a rev_id.
684
:return: The revno string, or None if the revision is not in the supplied
688
revno = branch.revision_id_to_dotted_revno(rev_id)
689
except errors.NoSuchRevision:
690
# The revision must be outside of this branch
693
return '.'.join(str(n) for n in revno)
626
696
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
697
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
628
698
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)
700
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
701
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
702
except errors.NoSuchRevision:
703
# one or both is not in the branch; not obvious
631
705
if len(start_dotted) == 1 and len(end_dotted) == 1:
632
706
# both on mainline
633
707
return start_dotted[0] <= end_dotted[0]
634
708
elif (len(start_dotted) == 3 and len(end_dotted) == 3 and
635
start_dotted[0:1] == end_dotted[0:1]):
709
start_dotted[0:1] == end_dotted[0:1]):
636
710
# both on same development line
637
711
return start_dotted[2] <= end_dotted[2]
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
720
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
721
exclude_common_ancestry=False):
647
722
"""Calculate a sequence of revisions to view, newest to oldest.
649
724
:param start_rev_id: the lower revision-id
650
725
:param end_rev_id: the upper revision-id
726
:param exclude_common_ancestry: Whether the start_rev_id should be part of
727
the iterated revisions.
651
728
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
729
dotted_revno will be None for ghosts
652
730
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
is not found walking the left-hand history
731
is not found walking the left-hand history
655
br_revno, br_rev_id = branch.last_revision_info()
656
733
repo = branch.repository
734
graph = repo.get_graph()
657
735
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
737
br_revno, br_rev_id = branch.last_revision_info()
738
except errors.GhostRevisionsHaveNoRevno:
739
br_rev_id = branch.last_revision()
743
graph_iter = graph.iter_lefthand_ancestry(br_rev_id,
744
(_mod_revision.NULL_REVISION,))
747
revision_id = next(graph_iter)
748
except errors.RevisionNotPresent as e:
750
yield e.revision_id, None, None
752
except StopIteration:
755
yield revision_id, str(cur_revno) if cur_revno is not None else None, 0
756
if cur_revno is not None:
759
br_rev_id = branch.last_revision()
663
760
if end_rev_id is None:
664
761
end_rev_id = br_rev_id
665
762
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
763
graph_iter = graph.iter_lefthand_ancestry(end_rev_id,
764
(_mod_revision.NULL_REVISION,))
767
revision_id = next(graph_iter)
768
except StopIteration:
770
except errors.RevisionNotPresent as e:
772
yield e.revision_id, None, None
674
yield revision_id, revno_str, 0
677
raise _StartNotLinearAncestor()
775
revno_str = _compute_revno_str(branch, revision_id)
776
if not found_start and revision_id == start_rev_id:
777
if not exclude_common_ancestry:
778
yield revision_id, revno_str, 0
782
yield revision_id, revno_str, 0
784
raise _StartNotLinearAncestor()
680
787
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
721
828
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
831
def _rebase_merge_depth(view_revisions):
744
832
"""Adjust depths upwards so the top level is 0."""
745
833
# If either the first or last revision have a merge_depth of 0, we're done
746
834
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])
835
min_depth = min([d for r, n, d in view_revisions])
748
836
if min_depth != 0:
749
view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
837
view_revisions = [(r, n, d - min_depth)
838
for r, n, d in view_revisions]
750
839
return view_revisions
753
842
def make_log_rev_iterator(branch, view_revisions, generate_delta, search,
754
file_ids=None, direction='reverse'):
843
file_ids=None, direction='reverse'):
755
844
"""Create a revision iterator for log.
757
846
:param branch: The branch being logged.
768
857
# Convert view_revisions into (view, None, None) groups to fit with
769
858
# the standard interface here.
770
if type(view_revisions) == list:
859
if isinstance(view_revisions, list):
771
860
# A single batch conversion is faster than many incremental ones.
772
861
# As we have all the data, do a batch conversion.
773
862
nones = [None] * len(view_revisions)
774
log_rev_iterator = iter([zip(view_revisions, nones, nones)])
863
log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
777
866
for view in view_revisions:
781
870
# It would be nicer if log adapters were first class objects
782
871
# with custom parameters. This will do for now. IGC 20090127
783
872
if adapter == _make_delta_filter:
784
log_rev_iterator = adapter(branch, generate_delta,
785
search, log_rev_iterator, file_ids, direction)
873
log_rev_iterator = adapter(
874
branch, generate_delta, search, log_rev_iterator, file_ids,
787
log_rev_iterator = adapter(branch, generate_delta,
788
search, log_rev_iterator)
877
log_rev_iterator = adapter(
878
branch, generate_delta, search, log_rev_iterator)
789
879
return log_rev_iterator
792
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
882
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
883
"""Create a filtered iterator of log_rev_iterator matching on a regex.
795
885
:param branch: The branch being logged.
796
886
:param generate_delta: Whether to generate a delta for each revision.
797
:param search: A user text search string.
887
:param match: A dictionary with properties as keys and lists of strings
888
as values. To match, a revision may match any of the supplied strings
889
within a single property but must match at least one string for each
798
891
:param log_rev_iterator: An input iterator containing all revisions that
799
892
could be displayed, in lists.
800
893
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
804
897
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):
898
# Use lazy_compile so mapping to InvalidPattern error occurs.
899
searchRE = [(k, [lazy_regex.lazy_compile(x, re.IGNORECASE) for x in v])
900
for k, v in match.items()]
901
return _filter_re(searchRE, log_rev_iterator)
904
def _filter_re(searchRE, log_rev_iterator):
811
905
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))
906
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
911
def _match_filter(searchRE, rev):
913
'message': (rev.message,),
914
'committer': (rev.committer,),
915
'author': (rev.get_apparent_authors()),
916
'bugs': list(rev.iter_bugs())
918
strings[''] = [item for inner_list in strings.values()
919
for item in inner_list]
920
for k, v in searchRE:
921
if k in strings and not _match_any_filter(strings[k], v):
926
def _match_any_filter(strings, res):
927
return any(r.search(s) for r in res for s in strings)
819
930
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
fileids=None, direction='reverse'):
931
fileids=None, direction='reverse'):
821
932
"""Add revision deltas to a log iterator if needed.
823
934
:param branch: The branch being logged.
866
977
if delta_type == 'full' and not check_fileids:
867
978
deltas = repository.get_deltas_for_revisions(revisions)
868
for rev, delta in izip(revs, deltas):
979
for rev, delta in zip(revs, deltas):
869
980
new_revs.append((rev[0], rev[1], delta))
871
982
deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
872
for rev, delta in izip(revs, deltas):
983
for rev, delta in zip(revs, deltas):
873
984
if check_fileids:
874
985
if delta is None or not delta.has_changed():
923
1034
for revs in log_rev_iterator:
924
1035
# r = revision_id, n = revno, d = merge depth
925
1036
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)]
1037
revisions = dict(repository.iter_revisions(revision_ids))
1038
yield [(rev[0], revisions[rev[0][0]], rev[2]) for rev in revs]
932
1041
def _make_batch_filter(branch, generate_delta, search, log_rev_iterator):
968
1075
:return: (start_rev_id, end_rev_id) tuple.
970
branch_revno, branch_rev_id = branch.last_revision_info()
971
1077
start_rev_id = None
972
if start_revision is None:
1079
if start_revision is not None:
1080
if not isinstance(start_revision, revisionspec.RevisionInfo):
1081
raise TypeError(start_revision)
1082
start_rev_id = start_revision.rev_id
1083
start_revno = start_revision.revno
1084
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
1087
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)
1089
if end_revision is not None:
1090
if not isinstance(end_revision, revisionspec.RevisionInfo):
1091
raise TypeError(start_revision)
1092
end_rev_id = end_revision.rev_id
1093
end_revno = end_revision.revno
1094
if end_revno is None:
1096
end_revno = branch.revno()
1097
except errors.GhostRevisionsHaveNoRevno:
995
if branch_revno != 0:
1100
if branch.last_revision() != _mod_revision.NULL_REVISION:
996
1101
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.")
1102
or end_rev_id == _mod_revision.NULL_REVISION):
1103
raise errors.BzrCommandError(
1104
gettext('Logging revision 0 is invalid.'))
1105
if end_revno is not None and start_revno > end_revno:
1106
raise errors.BzrCommandError(
1107
gettext("Start revision must be older than the end revision."))
1002
1108
return (start_rev_id, end_rev_id)
1052
1158
end_revno = end_revision
1054
1160
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.')
1161
or (end_rev_id == _mod_revision.NULL_REVISION)):
1162
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1057
1163
if start_revno > end_revno:
1058
raise errors.BzrCommandError("Start revision must be older than "
1059
"the end revision.")
1164
raise errors.BzrCommandError(gettext("Start revision must be older "
1165
"than the end revision."))
1061
1167
if end_revno < start_revno:
1062
1168
return None, None, None, None
1063
1169
cur_revno = branch_revno
1065
1171
mainline_revs = []
1066
for revision_id in branch.repository.iter_reverse_revision_history(
1067
branch_last_revision):
1172
graph = branch.repository.get_graph()
1173
for revision_id in graph.iter_lefthand_ancestry(
1174
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1068
1175
if cur_revno < start_revno:
1069
1176
# We have gone far enough, but we always add 1 more revision
1070
1177
rev_nos[revision_id] = cur_revno
1084
1191
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
1194
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
include_merges=True):
1195
include_merges=True):
1133
1196
r"""Return the list of revision ids which touch a given file id.
1135
1198
The function filters view_revisions and returns a subset.
1136
1199
This includes the revisions which directly change the file id,
1137
1200
and the revisions which merge these changes. So if the
1138
1201
revision graph is::
1177
1243
# indexing layer. We might consider passing in hints as to the known
1178
1244
# access pattern (sparse/clustered, high success rate/low success
1179
1245
# rate). This particular access is clustered with a low success rate.
1180
get_parent_map = branch.repository.texts.get_parent_map
1181
1246
modified_text_revisions = set()
1182
1247
chunk_size = 1000
1183
for start in xrange(0, len(text_keys), chunk_size):
1248
for start in range(0, len(text_keys), chunk_size):
1184
1249
next_keys = text_keys[start:start + chunk_size]
1185
1250
# Only keep the revision_id portion of the key
1186
1251
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
1278
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1279
"""Reverse revisions by depth.
1257
1281
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,
1282
revision of that depth. There may be no topological justification for this
1259
1283
but it looks much nicer.
1261
1285
# Add a fake revision at start so that we can always attach sub revisions
1312
1340
to indicate which LogRevision attributes it supports:
1314
1342
- 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.
1343
Otherwise the delta attribute may not be populated. The 'delta_format'
1344
attribute describes whether the 'short_status' format (1) or the long
1345
one (2) should be used.
1319
1347
- supports_merge_revisions must be True if this log formatter supports
1320
merge revisions. If not, then only mainline revisions will be passed
1348
merge revisions. If not, then only mainline revisions will be passed
1323
1351
- 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.
1352
The default value is zero meaning display all levels.
1353
This value is only relevant if supports_merge_revisions is True.
1327
1355
- supports_tags must be True if this log formatter supports tags.
1328
Otherwise the tags attribute may not be populated.
1356
Otherwise the tags attribute may not be populated.
1330
1358
- supports_diff must be True if this log formatter supports diffs.
1331
Otherwise the diff attribute may not be populated.
1359
Otherwise the diff attribute may not be populated.
1361
- supports_signatures must be True if this log formatter supports GPG
1333
1364
Plugins can register functions to show custom revision properties using
1334
1365
the properties_handler_registry. The registered function
1335
must respect the following interface description:
1366
must respect the following interface description::
1336
1368
def my_show_properties(properties_dict):
1337
1369
# code that returns a dict {'name':'value'} of the properties
1342
1374
def __init__(self, to_file, show_ids=False, show_timezone='original',
1343
1375
delta_format=None, levels=None, show_advice=False,
1344
to_exact_file=None):
1376
to_exact_file=None, author_list_handler=None):
1345
1377
"""Create a LogFormatter.
1347
1379
:param to_file: the file to output to
1348
:param to_exact_file: if set, gives an output stream to which
1380
:param to_exact_file: if set, gives an output stream to which
1349
1381
non-Unicode diffs are written.
1350
1382
:param show_ids: if True, revision-ids are to be displayed
1351
1383
:param show_timezone: the timezone to use
1355
1387
let the log formatter decide.
1356
1388
:param show_advice: whether to show advice at the end of the
1390
:param author_list_handler: callable generating a list of
1391
authors to display for a given revision
1359
1393
self.to_file = to_file
1360
1394
# 'exact' stream used to show diff, it should print content 'as is'
1361
# and should not try to decode/encode it to unicode to avoid bug #328007
1395
# and should not try to decode/encode it to unicode to avoid bug
1362
1397
if to_exact_file is not None:
1363
1398
self.to_exact_file = to_exact_file
1365
# XXX: somewhat hacky; this assumes it's a codec writer; it's better
1366
# for code that expects to get diffs to pass in the exact file
1400
# XXX: somewhat hacky; this assumes it's a codec writer; it's
1401
# better for code that expects to get diffs to pass in the exact
1368
1403
self.to_exact_file = getattr(to_file, 'stream', to_file)
1369
1404
self.show_ids = show_ids
1370
1405
self.show_timezone = show_timezone
1371
1406
if delta_format is None:
1372
1407
# Ensures backward compatibility
1373
delta_format = 2 # long format
1408
delta_format = 2 # long format
1374
1409
self.delta_format = delta_format
1375
1410
self.levels = levels
1376
1411
self._show_advice = show_advice
1377
1412
self._merge_count = 0
1413
self._author_list_handler = author_list_handler
1379
1415
def get_levels(self):
1380
1416
"""Get the number of levels to display or 0 for all."""
1414
1450
def short_author(self, rev):
1415
name, address = config.parse_username(rev.get_apparent_authors()[0])
1451
return self.authors(rev, 'first', short=True, sep=', ')
1453
def authors(self, rev, who, short=False, sep=None):
1454
"""Generate list of authors, taking --authors option into account.
1456
The caller has to specify the name of a author list handler,
1457
as provided by the author list registry, using the ``who``
1458
argument. That name only sets a default, though: when the
1459
user selected a different author list generation using the
1460
``--authors`` command line switch, as represented by the
1461
``author_list_handler`` constructor argument, that value takes
1464
:param rev: The revision for which to generate the list of authors.
1465
:param who: Name of the default handler.
1466
:param short: Whether to shorten names to either name or address.
1467
:param sep: What separator to use for automatic concatenation.
1469
if self._author_list_handler is not None:
1470
# The user did specify --authors, which overrides the default
1471
author_list_handler = self._author_list_handler
1473
# The user didn't specify --authors, so we use the caller's default
1474
author_list_handler = author_list_registry.get(who)
1475
names = author_list_handler(rev)
1477
for i in range(len(names)):
1478
name, address = config.parse_username(names[i])
1484
names = sep.join(names)
1420
1487
def merge_marker(self, revision):
1421
1488
"""Get the merge marker to include in the output or '' if none."""
1513
1586
lines = [_LONG_SEP]
1514
1587
if revision.revno is not None:
1515
1588
lines.append('revno: %s%s' % (revision.revno,
1516
self.merge_marker(revision)))
1589
self.merge_marker(revision)))
1517
1590
if revision.tags:
1518
lines.append('tags: %s' % (', '.join(revision.tags)))
1591
lines.append('tags: %s' % (', '.join(sorted(revision.tags))))
1592
if self.show_ids or revision.revno is None:
1593
lines.append('revision-id: %s' %
1594
(revision.rev.revision_id.decode('utf-8'),))
1519
1595
if self.show_ids:
1520
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1521
1596
for parent_id in revision.rev.parent_ids:
1522
lines.append('parent: %s' % (parent_id,))
1597
lines.append('parent: %s' % (parent_id.decode('utf-8'),))
1523
1598
lines.extend(self.custom_properties(revision.rev))
1525
1600
committer = revision.rev.committer
1526
authors = revision.rev.get_apparent_authors()
1601
authors = self.authors(revision.rev, 'all')
1527
1602
if authors != [committer]:
1528
1603
lines.append('author: %s' % (", ".join(authors),))
1529
1604
lines.append('committer: %s' % (committer,))
1547
1625
to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1548
1626
if revision.delta is not None:
1549
1627
# Use the standard status output to display changes
1550
from bzrlib.delta import report_delta
1551
report_delta(to_file, revision.delta, short_status=False,
1628
from breezy.delta import report_delta
1629
report_delta(to_file, revision.delta, short_status=False,
1552
1630
show_ids=self.show_ids, indent=indent)
1553
1631
if revision.diff is not None:
1554
1632
to_file.write(indent + 'diff:\n')
1598
1676
to_file = self.to_file
1600
1678
if revision.tags:
1601
tags = ' {%s}' % (', '.join(revision.tags))
1679
tags = ' {%s}' % (', '.join(sorted(revision.tags)))
1602
1680
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1603
revision.revno, self.short_author(revision.rev),
1604
format_date(revision.rev.timestamp,
1605
revision.rev.timezone or 0,
1606
self.show_timezone, date_fmt="%Y-%m-%d",
1608
tags, self.merge_marker(revision)))
1609
self.show_properties(revision.rev, indent+offset)
1681
revision.revno or "", self.short_author(
1683
format_date(revision.rev.timestamp,
1684
revision.rev.timezone or 0,
1685
self.show_timezone, date_fmt="%Y-%m-%d",
1687
tags, self.merge_marker(revision)))
1688
self.show_properties(revision.rev, indent + offset)
1689
if self.show_ids or revision.revno is None:
1611
1690
to_file.write(indent + offset + 'revision-id:%s\n'
1612
% (revision.rev.revision_id,))
1691
% (revision.rev.revision_id.decode('utf-8'),))
1613
1692
if not revision.rev.message:
1614
1693
to_file.write(indent + offset + '(no message)\n')
1620
1699
if revision.delta is not None:
1621
1700
# Use the standard status output to display changes
1622
from bzrlib.delta import report_delta
1623
report_delta(to_file, revision.delta,
1624
short_status=self.delta_format==1,
1701
from breezy.delta import report_delta
1702
report_delta(to_file, revision.delta,
1703
short_status=self.delta_format == 1,
1625
1704
show_ids=self.show_ids, indent=indent + offset)
1626
1705
if revision.diff is not None:
1627
1706
self.show_diff(self.to_exact_file, revision.diff, ' ')
1661
1740
def log_revision(self, revision):
1662
1741
indent = ' ' * revision.merge_depth
1663
1742
self.to_file.write(self.log_string(revision.revno, revision.rev,
1664
self._max_chars, revision.tags, indent))
1743
self._max_chars, revision.tags, indent))
1665
1744
self.to_file.write('\n')
1667
1746
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1668
1747
"""Format log info into one string. Truncate tail of string
1669
:param revno: revision number or None.
1670
Revision numbers counts from 1.
1671
:param rev: revision object
1672
:param max_chars: maximum length of resulting string
1673
:param tags: list of tags or None
1674
:param prefix: string to prefix each line
1675
:return: formatted truncated string
1749
:param revno: revision number or None.
1750
Revision numbers counts from 1.
1751
:param rev: revision object
1752
:param max_chars: maximum length of resulting string
1753
:param tags: list of tags or None
1754
:param prefix: string to prefix each line
1755
:return: formatted truncated string
1679
1759
# show revno only when is not None
1680
1760
out.append("%s:" % revno)
1681
out.append(self.truncate(self.short_author(rev), 20))
1761
if max_chars is not None:
1762
out.append(self.truncate(
1763
self.short_author(rev), (max_chars + 3) // 4))
1765
out.append(self.short_author(rev))
1682
1766
out.append(self.date_string(rev))
1683
1767
if len(rev.parent_ids) > 1:
1684
1768
out.append('[merge]')
1686
tag_str = '{%s}' % (', '.join(tags))
1770
tag_str = '{%s}' % (', '.join(sorted(tags)))
1687
1771
out.append(tag_str)
1688
1772
out.append(rev.get_summary())
1689
1773
return self.truncate(prefix + " ".join(out).rstrip('\n'), max_chars)
1703
1787
self.show_timezone,
1704
1788
date_fmt='%Y-%m-%d',
1705
1789
show_offset=False)
1706
committer_str = revision.rev.get_apparent_authors()[0].replace (' <', ' <')
1707
to_file.write('%s %s\n\n' % (date_str,committer_str))
1790
committer_str = self.authors(revision.rev, 'first', sep=', ')
1791
committer_str = committer_str.replace(' <', ' <')
1792
to_file.write('%s %s\n\n' % (date_str, committer_str))
1709
1794
if revision.delta is not None and revision.delta.has_changed():
1710
1795
for c in revision.delta.added + revision.delta.removed + revision.delta.modified:
1712
1797
to_file.write('\t* %s:\n' % (path,))
1713
1798
for c in revision.delta.renamed:
1714
oldpath,newpath = c[:2]
1799
oldpath, newpath = c[:2]
1715
1800
# For renamed files, show both the old and the new path
1716
to_file.write('\t* %s:\n\t* %s:\n' % (oldpath,newpath))
1801
to_file.write('\t* %s:\n\t* %s:\n' % (oldpath, newpath))
1717
1802
to_file.write('\n')
1719
1804
if not revision.rev.message:
1742
1827
return self.get(name)(*args, **kwargs)
1744
1829
def get_default(self, branch):
1745
return self.get(branch.get_config().log_format())
1830
c = branch.get_config_stack()
1831
return self.get(c.get('log_format'))
1748
1834
log_formatter_registry = LogFormatterRegistry()
1751
1837
log_formatter_registry.register('short', ShortLogFormatter,
1752
'Moderately short log format')
1838
'Moderately short log format.')
1753
1839
log_formatter_registry.register('long', LongLogFormatter,
1754
'Detailed log format')
1840
'Detailed log format.')
1755
1841
log_formatter_registry.register('line', LineLogFormatter,
1756
'Log format with one line per revision')
1842
'Log format with one line per revision.')
1757
1843
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1758
'Format used by GNU ChangeLog files')
1844
'Format used by GNU ChangeLog files.')
1761
1847
def register_formatter(name, formatter):
1772
1858
return log_formatter_registry.make_formatter(name, *args, **kwargs)
1773
1859
except KeyError:
1774
raise errors.BzrCommandError("unknown log formatter: %r" % name)
1777
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1778
# deprecated; for compatibility
1779
lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
1780
lf.show(revno, rev, delta)
1860
raise errors.BzrCommandError(
1861
gettext("unknown log formatter: %r") % name)
1864
def author_list_all(rev):
1865
return rev.get_apparent_authors()[:]
1868
def author_list_first(rev):
1869
lst = rev.get_apparent_authors()
1876
def author_list_committer(rev):
1877
return [rev.committer]
1880
author_list_registry = registry.Registry()
1882
author_list_registry.register('all', author_list_all,
1885
author_list_registry.register('first', author_list_first,
1888
author_list_registry.register('committer', author_list_committer,
1783
1892
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1800
1909
# This is the first index which is different between
1802
1911
base_idx = None
1803
for i in xrange(max(len(new_rh),
1912
for i in range(max(len(new_rh), len(old_rh))):
1805
1913
if (len(new_rh) <= i
1806
1914
or len(old_rh) <= i
1807
or new_rh[i] != old_rh[i]):
1915
or new_rh[i] != old_rh[i]):
1811
1919
if base_idx is None:
1812
1920
to_file.write('Nothing seems to have changed\n')
1814
## TODO: It might be nice to do something like show_log
1815
## and show the merged entries. But since this is the
1816
## removed revisions, it shouldn't be as important
1922
# TODO: It might be nice to do something like show_log
1923
# and show the merged entries. But since this is the
1924
# removed revisions, it shouldn't be as important
1817
1925
if base_idx < len(old_rh):
1818
to_file.write('*'*60)
1926
to_file.write('*' * 60)
1819
1927
to_file.write('\nRemoved Revisions:\n')
1820
1928
for i in range(base_idx, len(old_rh)):
1821
1929
rev = branch.repository.get_revision(old_rh[i])
1822
lr = LogRevision(rev, i+1, 0, None)
1930
lr = LogRevision(rev, i + 1, 0, None)
1823
1931
lf.log_revision(lr)
1824
to_file.write('*'*60)
1932
to_file.write('*' * 60)
1825
1933
to_file.write('\n\n')
1826
1934
if base_idx < len(new_rh):
1827
1935
to_file.write('Added Revisions:\n')
1828
1936
show_log(branch,
1832
1939
direction='forward',
1833
start_revision=base_idx+1,
1940
start_revision=base_idx + 1,
1834
1941
end_revision=len(new_rh),
1903
2011
log_format = log_formatter_registry.get_default(branch)
1904
2012
lf = log_format(show_ids=False, to_file=output, show_timezone='original')
1905
2013
if old_history != []:
1906
output.write('*'*60)
2014
output.write('*' * 60)
1907
2015
output.write('\nRemoved Revisions:\n')
1908
2016
show_flat_log(branch.repository, old_history, old_revno, lf)
1909
output.write('*'*60)
2017
output.write('*' * 60)
1910
2018
output.write('\n\n')
1911
2019
if new_history != []:
1912
2020
output.write('Added Revisions:\n')
1913
2021
start_revno = new_revno - len(new_history) + 1
1914
show_log(branch, lf, None, verbose=False, direction='forward',
1915
start_revision=start_revno,)
2022
show_log(branch, lf, verbose=False, direction='forward',
2023
start_revision=start_revno)
1918
2026
def show_flat_log(repository, history, last_revno, lf):
1923
2031
:param last_revno: The revno of the last revision_id in the history.
1924
2032
:param lf: The log formatter to use.
1926
start_revno = last_revno - len(history) + 1
1927
2034
revisions = repository.get_revisions(history)
1928
2035
for i, rev in enumerate(revisions):
1929
2036
lr = LogRevision(rev, i + last_revno, 0, None)
1930
2037
lf.log_revision(lr)
1933
def _get_info_for_log_files(revisionspec_list, file_list):
2040
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
1934
2041
"""Find file-ids and kinds given a list of files and a revision range.
1936
2043
We search for files at the end of the range. If not found there,
1940
2047
:param file_list: the list of paths given on the command line;
1941
2048
the first of these can be a branch location or a file path,
1942
2049
the remainder must be file paths
2050
:param add_cleanup: When the branch returned is read locked,
2051
an unlock call will be queued to the cleanup.
1943
2052
:return: (branch, info_list, start_rev_info, end_rev_info) where
1944
2053
info_list is a list of (relative_path, file_id, kind) tuples where
1945
2054
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1946
2055
branch will be read-locked.
1948
from builtins import _get_revision_range, safe_relpath_files
1949
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2057
from breezy.builtins import _get_revision_range
2058
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2060
add_cleanup(b.lock_read().unlock)
1951
2061
# XXX: It's damn messy converting a list of paths to relative paths when
1952
2062
# those paths might be deleted ones, they might be on a case-insensitive
1953
2063
# filesystem and/or they might be in silly locations (like another branch).
1957
2067
# case of running log in a nested directory, assuming paths beyond the
1958
2068
# first one haven't been deleted ...
1960
relpaths = [path] + safe_relpath_files(tree, file_list[1:])
2070
relpaths = [path] + tree.safe_relpath_files(file_list[1:])
1962
2072
relpaths = [path] + file_list[1:]
1964
2074
start_rev_info, end_rev_info = _get_revision_range(revisionspec_list, b,
1966
2076
if relpaths in ([], [u'']):
1967
2077
return b, [], start_rev_info, end_rev_info
1968
2078
if start_rev_info is None and end_rev_info is None:
2018
2128
tree1 = b.repository.revision_tree(rev_id)
2019
2129
file_id = tree1.path2id(fp)
2020
kind = _get_kind_for_file_id(tree1, file_id)
2130
kind = _get_kind_for_file_id(tree1, fp, file_id)
2021
2131
info_list.append((fp, file_id, kind))
2022
2132
return b, info_list, start_rev_info, end_rev_info
2025
def _get_kind_for_file_id(tree, file_id):
2135
def _get_kind_for_file_id(tree, path, file_id):
2026
2136
"""Return the kind of a file-id or None if it doesn't exist."""
2027
2137
if file_id is not None:
2028
return tree.kind(file_id)
2138
return tree.kind(path)
2033
2143
properties_handler_registry = registry.Registry()
2035
2145
# Use the properties handlers to print out bug information if available
2036
2148
def _bugs_properties_handler(revision):
2037
if revision.properties.has_key('bugs'):
2038
bug_lines = revision.properties['bugs'].split('\n')
2039
bug_rows = [line.split(' ', 1) for line in bug_lines]
2040
fixed_bug_urls = [row[0] for row in bug_rows if
2041
len(row) > 1 and row[1] == 'fixed']
2150
related_bug_urls = []
2151
for bug_url, status in revision.iter_bugs():
2152
if status == 'fixed':
2153
fixed_bug_urls.append(bug_url)
2154
elif status == 'related':
2155
related_bug_urls.append(bug_url)
2158
text = ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls))
2159
ret[text] = ' '.join(fixed_bug_urls)
2160
if related_bug_urls:
2161
text = ngettext('related bug', 'related bugs',
2162
len(related_bug_urls))
2163
ret[text] = ' '.join(related_bug_urls)
2044
return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2047
2167
properties_handler_registry.register('bugs_properties_handler',
2048
2168
_bugs_properties_handler)
added
removed
breezy/log.py
