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 (
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):
91
from .tree import find_previous_path
94
def find_touching_revisions(repository, last_revision, last_tree, last_path):
98
95
"""Yield a description of revisions which affect the file_id.
100
97
Each returned element is (revno, revision_id, description)
105
102
TODO: Perhaps some way to limit this to only particular revisions,
106
103
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
105
last_verifier = last_tree.get_file_verifier(last_path)
106
graph = repository.get_graph()
107
history = list(graph.iter_lefthand_ancestry(last_revision, []))
109
for revision_id in history:
110
this_tree = repository.revision_tree(revision_id)
111
this_path = find_previous_path(last_tree, this_tree, last_path)
119
113
# now we know how it was last time, and how it is in this revision.
120
114
# 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
115
if this_path is not None and last_path is None:
116
yield revno, revision_id, "deleted " + this_path
117
this_verifier = this_tree.get_file_verifier(this_path)
118
elif this_path is None and last_path is not None:
119
yield revno, revision_id, "added " + last_path
130
120
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
121
yield revno, revision_id, ("renamed %s => %s" % (this_path, last_path))
122
this_verifier = this_tree.get_file_verifier(this_path)
124
this_verifier = this_tree.get_file_verifier(this_path)
125
if (this_verifier != last_verifier):
126
yield revno, revision_id, "modified " + this_path
128
last_verifier = this_verifier
137
129
last_path = this_path
141
def _enumerate_history(branch):
144
for rev_id in branch.revision_history():
145
rh.append((revno, rev_id))
130
last_tree = this_tree
131
if last_path is None:
150
136
def show_log(branch,
199
if isinstance(start_revision, int):
201
start_revision = revisionspec.RevisionInfo(branch, start_revision)
202
except errors.NoSuchRevision:
203
raise errors.InvalidRevisionNumber(start_revision)
205
if isinstance(end_revision, int):
207
end_revision = revisionspec.RevisionInfo(branch, end_revision)
208
except errors.NoSuchRevision:
209
raise errors.InvalidRevisionNumber(end_revision)
211
if end_revision is not None and end_revision.revno == 0:
212
raise errors.InvalidRevisionNumber(end_revision.revno)
209
214
# Build the request and execute it
210
215
rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
211
start_revision=start_revision, end_revision=end_revision,
212
limit=limit, message_search=search,
213
delta_type=delta_type, diff_type=diff_type)
216
start_revision=start_revision, end_revision=end_revision,
217
limit=limit, message_search=search,
218
delta_type=delta_type, diff_type=diff_type)
214
219
Logger(branch, rqst).show(lf)
217
# Note: This needs to be kept this in sync with the defaults in
222
# Note: This needs to be kept in sync with the defaults in
218
223
# make_log_request_dict() below
219
224
_DEFAULT_REQUEST_PARAMS = {
220
225
'direction': 'reverse',
222
227
'generate_tags': True,
223
228
'exclude_common_ancestry': False,
224
229
'_match_using_deltas': True,
228
233
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
234
start_revision=None, end_revision=None, limit=None,
230
message_search=None, levels=1, generate_tags=True,
235
message_search=None, levels=None, generate_tags=True,
232
237
diff_type=None, _match_using_deltas=True,
233
exclude_common_ancestry=False,
238
exclude_common_ancestry=False, match=None,
239
signature=False, omit_merges=False,
235
241
"""Convenience function for making a logging request dictionary.
274
281
:param _match_using_deltas: a private parameter controlling the
275
282
algorithm used for matching specific_fileids. This parameter
276
may be removed in the future so bzrlib client code should NOT
283
may be removed in the future so breezy client code should NOT
279
286
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
287
range operator or as a graph difference.
289
:param signature: show digital signature information
291
:param match: Dictionary of list of search strings to use when filtering
292
revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
293
the empty string to match any of the preceding properties.
295
:param omit_merges: If True, commits with more than one parent are
299
# Take care of old style message_search parameter
302
if 'message' in match:
303
match['message'].append(message_search)
305
match['message'] = [message_search]
307
match = {'message': [message_search]}
283
309
'direction': direction,
284
310
'specific_fileids': specific_fileids,
285
311
'start_revision': start_revision,
286
312
'end_revision': end_revision,
288
'message_search': message_search,
289
314
'levels': levels,
290
315
'generate_tags': generate_tags,
291
316
'delta_type': delta_type,
292
317
'diff_type': diff_type,
293
318
'exclude_common_ancestry': exclude_common_ancestry,
319
'signature': signature,
321
'omit_merges': omit_merges,
294
322
# Add 'private' attributes for features that may be deprecated
295
323
'_match_using_deltas': _match_using_deltas,
299
327
def _apply_log_request_defaults(rqst):
300
328
"""Apply default values to a request dictionary."""
301
result = _DEFAULT_REQUEST_PARAMS
329
result = _DEFAULT_REQUEST_PARAMS.copy()
303
331
result.update(rqst)
335
def format_signature_validity(rev_id, branch):
336
"""get the signature validity
338
:param rev_id: revision id to validate
339
:param branch: branch of revision
340
:return: human readable string to print to log
342
from breezy import gpg
344
gpg_strategy = gpg.GPGStrategy(branch.get_config_stack())
345
result = branch.repository.verify_revision_signature(rev_id, gpg_strategy)
346
if result[0] == gpg.SIGNATURE_VALID:
347
return u"valid signature from {0}".format(result[1])
348
if result[0] == gpg.SIGNATURE_KEY_MISSING:
349
return "unknown key {0}".format(result[1])
350
if result[0] == gpg.SIGNATURE_NOT_VALID:
351
return "invalid signature!"
352
if result[0] == gpg.SIGNATURE_NOT_SIGNED:
353
return "no signature"
307
356
class LogGenerator(object):
308
357
"""A generator of log revisions."""
354
400
# Tweak the LogRequest based on what the LogFormatter can handle.
355
401
# (There's no point generating stuff if the formatter can't display it.)
357
rqst['levels'] = lf.get_levels()
403
if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
404
# user didn't specify levels, use whatever the LF can handle:
405
rqst['levels'] = lf.get_levels()
358
407
if not getattr(lf, 'supports_tags', False):
359
408
rqst['generate_tags'] = False
360
409
if not getattr(lf, 'supports_delta', False):
361
410
rqst['delta_type'] = None
362
411
if not getattr(lf, 'supports_diff', False):
363
412
rqst['diff_type'] = None
413
if not getattr(lf, 'supports_signatures', False):
414
rqst['signature'] = False
365
416
# Find and print the interesting revisions
366
417
generator = self._generator_factory(self.branch, rqst)
367
for lr in generator.iter_log_revisions():
419
for lr in generator.iter_log_revisions():
421
except errors.GhostRevisionUnusableHere:
422
raise errors.BzrCommandError(
423
gettext('Further revision history missing.'))
371
426
def _generator_factory(self, branch, rqst):
372
427
"""Make the LogGenerator object to use.
374
429
Subclasses may wish to override this.
376
431
return _DefaultLogGenerator(branch, rqst)
400
455
levels = rqst.get('levels')
401
456
limit = rqst.get('limit')
402
457
diff_type = rqst.get('diff_type')
458
show_signature = rqst.get('signature')
459
omit_merges = rqst.get('omit_merges')
404
461
revision_iterator = self._create_log_revision_iterator()
405
462
for revs in revision_iterator:
406
463
for (rev_id, revno, merge_depth), rev, delta in revs:
407
464
# 0 levels means show everything; merge_depth counts from 0
408
if levels != 0 and merge_depth >= levels:
465
if (levels != 0 and merge_depth is not None and
466
merge_depth >= levels):
468
if omit_merges and len(rev.parent_ids) > 1:
471
raise errors.GhostRevisionUnusableHere(rev_id)
410
472
if diff_type is None:
413
475
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)
477
signature = format_signature_validity(rev_id, self.branch)
481
rev, revno, merge_depth, delta,
482
self.rev_tag_dict.get(rev_id), diff, signature)
418
485
if log_count >= limit:
473
542
# Apply the other filters
474
543
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'))
544
rqst.get('delta_type'), rqst.get('match'),
545
file_ids=rqst.get('specific_fileids'),
546
direction=rqst.get('direction'))
479
548
def _log_revision_iterator_using_per_file_graph(self):
480
549
# Get the base revisions, filtering by the revision range.
488
557
if not isinstance(view_revisions, list):
489
558
view_revisions = list(view_revisions)
490
559
view_revisions = _filter_revisions_touching_file_id(self.branch,
491
rqst.get('specific_fileids')[0], view_revisions,
492
include_merges=rqst.get('levels') != 1)
560
rqst.get('specific_fileids')[
562
include_merges=rqst.get('levels') != 1)
493
563
return make_log_rev_iterator(self.branch, view_revisions,
494
rqst.get('delta_type'), rqst.get('message_search'))
564
rqst.get('delta_type'), rqst.get('match'))
497
567
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
575
a list of the same tuples.
507
577
if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
578
raise errors.BzrCommandError(gettext(
579
'--exclude-common-ancestry requires two different revisions'))
510
580
if direction not in ('reverse', 'forward'):
511
raise ValueError('invalid direction %r' % direction)
512
br_revno, br_rev_id = branch.last_revision_info()
581
raise ValueError(gettext('invalid direction %r') % direction)
582
br_rev_id = branch.last_revision()
583
if br_rev_id == _mod_revision.NULL_REVISION:
516
586
if (end_rev_id and start_rev_id == end_rev_id
517
587
and (not generate_merge_revisions
518
588
or not _has_merges(branch, end_rev_id))):
519
589
# 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)))
590
return _generate_one_revision(branch, end_rev_id, br_rev_id,
592
if not generate_merge_revisions:
594
# If we only want to see linear revisions, we can iterate ...
595
iter_revs = _linear_view_revisions(
596
branch, start_rev_id, end_rev_id,
597
exclude_common_ancestry=exclude_common_ancestry)
598
# If a start limit was given and it's not obviously an
599
# ancestor of the end limit, check it before outputting anything
600
if (direction == 'forward'
601
or (start_rev_id and not _is_obvious_ancestor(
602
branch, start_rev_id, end_rev_id))):
603
iter_revs = list(iter_revs)
604
if direction == 'forward':
605
iter_revs = reversed(iter_revs)
607
except _StartNotLinearAncestor:
608
# Switch to the slower implementation that may be able to find a
609
# non-obvious ancestor out of the left-hand history.
611
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
612
direction, delayed_graph_generation,
613
exclude_common_ancestry)
614
if direction == 'forward':
615
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
540
622
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)
624
revno_str = _compute_revno_str(branch, rev_id)
544
625
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
628
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
629
delayed_graph_generation,
563
630
exclude_common_ancestry=False):
571
638
initial_revisions = []
572
639
if delayed_graph_generation:
574
for rev_id, revno, depth in _linear_view_revisions(
575
branch, start_rev_id, end_rev_id):
641
for rev_id, revno, depth in _linear_view_revisions(
642
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
576
643
if _has_merges(branch, rev_id):
577
644
# The end_rev_id can be nested down somewhere. We need an
578
645
# explicit ancestry check. There is an ambiguity here as we
610
677
# shown naturally, i.e. just like it is for linear logging. We can easily
611
678
# make forward the exact opposite display, but showing the merge revisions
612
679
# 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))
680
view_revisions = itertools.chain(iter(initial_revisions),
681
_graph_view_revisions(branch, start_rev_id, end_rev_id,
682
rebase_initial_depths=(
683
direction == 'reverse'),
684
exclude_common_ancestry=exclude_common_ancestry))
617
685
return view_revisions
623
691
return len(parents) > 1
694
def _compute_revno_str(branch, rev_id):
695
"""Compute the revno string from a rev_id.
697
:return: The revno string, or None if the revision is not in the supplied
701
revno = branch.revision_id_to_dotted_revno(rev_id)
702
except errors.NoSuchRevision:
703
# The revision must be outside of this branch
706
return '.'.join(str(n) for n in revno)
626
709
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
710
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
628
711
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)
713
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
714
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
715
except errors.NoSuchRevision:
716
# one or both is not in the branch; not obvious
631
718
if len(start_dotted) == 1 and len(end_dotted) == 1:
632
719
# both on mainline
633
720
return start_dotted[0] <= end_dotted[0]
634
721
elif (len(start_dotted) == 3 and len(end_dotted) == 3 and
635
start_dotted[0:1] == end_dotted[0:1]):
722
start_dotted[0:1] == end_dotted[0:1]):
636
723
# both on same development line
637
724
return start_dotted[2] <= end_dotted[2]
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
733
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
734
exclude_common_ancestry=False):
647
735
"""Calculate a sequence of revisions to view, newest to oldest.
649
737
:param start_rev_id: the lower revision-id
650
738
:param end_rev_id: the upper revision-id
739
:param exclude_common_ancestry: Whether the start_rev_id should be part of
740
the iterated revisions.
651
741
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
742
dotted_revno will be None for ghosts
652
743
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
is not found walking the left-hand history
744
is not found walking the left-hand history
655
br_revno, br_rev_id = branch.last_revision_info()
656
746
repo = branch.repository
747
graph = repo.get_graph()
657
748
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
750
br_revno, br_rev_id = branch.last_revision_info()
751
except errors.GhostRevisionsHaveNoRevno:
752
br_rev_id = branch.last_revision()
756
graph_iter = graph.iter_lefthand_ancestry(br_rev_id,
757
(_mod_revision.NULL_REVISION,))
760
revision_id = next(graph_iter)
761
except errors.RevisionNotPresent as e:
763
yield e.revision_id, None, None
765
except StopIteration:
768
yield revision_id, str(cur_revno) if cur_revno is not None else None, 0
769
if cur_revno is not None:
772
br_rev_id = branch.last_revision()
663
773
if end_rev_id is None:
664
774
end_rev_id = br_rev_id
665
775
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
776
graph_iter = graph.iter_lefthand_ancestry(end_rev_id,
777
(_mod_revision.NULL_REVISION,))
780
revision_id = next(graph_iter)
781
except StopIteration:
783
except errors.RevisionNotPresent as e:
785
yield e.revision_id, None, None
674
yield revision_id, revno_str, 0
677
raise _StartNotLinearAncestor()
788
revno_str = _compute_revno_str(branch, revision_id)
789
if not found_start and revision_id == start_rev_id:
790
if not exclude_common_ancestry:
791
yield revision_id, revno_str, 0
795
yield revision_id, revno_str, 0
797
raise _StartNotLinearAncestor()
680
800
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
721
841
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
844
def _rebase_merge_depth(view_revisions):
744
845
"""Adjust depths upwards so the top level is 0."""
745
846
# If either the first or last revision have a merge_depth of 0, we're done
746
847
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])
848
min_depth = min([d for r, n, d in view_revisions])
748
849
if min_depth != 0:
749
view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
850
view_revisions = [(r, n, d - min_depth)
851
for r, n, d in view_revisions]
750
852
return view_revisions
753
855
def make_log_rev_iterator(branch, view_revisions, generate_delta, search,
754
file_ids=None, direction='reverse'):
856
file_ids=None, direction='reverse'):
755
857
"""Create a revision iterator for log.
757
859
:param branch: The branch being logged.
768
870
# Convert view_revisions into (view, None, None) groups to fit with
769
871
# the standard interface here.
770
if type(view_revisions) == list:
872
if isinstance(view_revisions, list):
771
873
# A single batch conversion is faster than many incremental ones.
772
874
# As we have all the data, do a batch conversion.
773
875
nones = [None] * len(view_revisions)
774
log_rev_iterator = iter([zip(view_revisions, nones, nones)])
876
log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
777
879
for view in view_revisions:
781
883
# It would be nicer if log adapters were first class objects
782
884
# with custom parameters. This will do for now. IGC 20090127
783
885
if adapter == _make_delta_filter:
784
log_rev_iterator = adapter(branch, generate_delta,
785
search, log_rev_iterator, file_ids, direction)
886
log_rev_iterator = adapter(
887
branch, generate_delta, search, log_rev_iterator, file_ids,
787
log_rev_iterator = adapter(branch, generate_delta,
788
search, log_rev_iterator)
890
log_rev_iterator = adapter(
891
branch, generate_delta, search, log_rev_iterator)
789
892
return log_rev_iterator
792
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
895
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
896
"""Create a filtered iterator of log_rev_iterator matching on a regex.
795
898
:param branch: The branch being logged.
796
899
:param generate_delta: Whether to generate a delta for each revision.
797
:param search: A user text search string.
900
:param match: A dictionary with properties as keys and lists of strings
901
as values. To match, a revision may match any of the supplied strings
902
within a single property but must match at least one string for each
798
904
:param log_rev_iterator: An input iterator containing all revisions that
799
905
could be displayed, in lists.
800
906
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
804
910
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):
911
# Use lazy_compile so mapping to InvalidPattern error occurs.
912
searchRE = [(k, [lazy_regex.lazy_compile(x, re.IGNORECASE) for x in v])
913
for k, v in match.items()]
914
return _filter_re(searchRE, log_rev_iterator)
917
def _filter_re(searchRE, log_rev_iterator):
811
918
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))
919
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
924
def _match_filter(searchRE, rev):
926
'message': (rev.message,),
927
'committer': (rev.committer,),
928
'author': (rev.get_apparent_authors()),
929
'bugs': list(rev.iter_bugs())
931
strings[''] = [item for inner_list in strings.values()
932
for item in inner_list]
933
for k, v in searchRE:
934
if k in strings and not _match_any_filter(strings[k], v):
939
def _match_any_filter(strings, res):
940
return any(r.search(s) for r in res for s in strings)
819
943
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
fileids=None, direction='reverse'):
944
fileids=None, direction='reverse'):
821
945
"""Add revision deltas to a log iterator if needed.
823
947
:param branch: The branch being logged.
866
990
if delta_type == 'full' and not check_fileids:
867
991
deltas = repository.get_deltas_for_revisions(revisions)
868
for rev, delta in izip(revs, deltas):
992
for rev, delta in zip(revs, deltas):
869
993
new_revs.append((rev[0], rev[1], delta))
871
995
deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
872
for rev, delta in izip(revs, deltas):
996
for rev, delta in zip(revs, deltas):
873
997
if check_fileids:
874
998
if delta is None or not delta.has_changed():
923
1047
for revs in log_rev_iterator:
924
1048
# r = revision_id, n = revno, d = merge depth
925
1049
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)]
1050
revisions = dict(repository.iter_revisions(revision_ids))
1051
yield [(rev[0], revisions[rev[0][0]], rev[2]) for rev in revs]
932
1054
def _make_batch_filter(branch, generate_delta, search, log_rev_iterator):
968
1088
:return: (start_rev_id, end_rev_id) tuple.
970
branch_revno, branch_rev_id = branch.last_revision_info()
971
1090
start_rev_id = None
972
if start_revision is None:
1092
if start_revision is not None:
1093
if not isinstance(start_revision, revisionspec.RevisionInfo):
1094
raise TypeError(start_revision)
1095
start_rev_id = start_revision.rev_id
1096
start_revno = start_revision.revno
1097
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
1100
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)
1102
if end_revision is not None:
1103
if not isinstance(end_revision, revisionspec.RevisionInfo):
1104
raise TypeError(start_revision)
1105
end_rev_id = end_revision.rev_id
1106
end_revno = end_revision.revno
1107
if end_revno is None:
1109
end_revno = branch.revno()
1110
except errors.GhostRevisionsHaveNoRevno:
995
if branch_revno != 0:
1113
if branch.last_revision() != _mod_revision.NULL_REVISION:
996
1114
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.")
1115
or end_rev_id == _mod_revision.NULL_REVISION):
1116
raise errors.BzrCommandError(
1117
gettext('Logging revision 0 is invalid.'))
1118
if end_revno is not None and start_revno > end_revno:
1119
raise errors.BzrCommandError(
1120
gettext("Start revision must be older than the end revision."))
1002
1121
return (start_rev_id, end_rev_id)
1052
1171
end_revno = end_revision
1054
1173
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.')
1174
or (end_rev_id == _mod_revision.NULL_REVISION)):
1175
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1057
1176
if start_revno > end_revno:
1058
raise errors.BzrCommandError("Start revision must be older than "
1059
"the end revision.")
1177
raise errors.BzrCommandError(gettext("Start revision must be older "
1178
"than the end revision."))
1061
1180
if end_revno < start_revno:
1062
1181
return None, None, None, None
1063
1182
cur_revno = branch_revno
1065
1184
mainline_revs = []
1066
for revision_id in branch.repository.iter_reverse_revision_history(
1067
branch_last_revision):
1185
graph = branch.repository.get_graph()
1186
for revision_id in graph.iter_lefthand_ancestry(
1187
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1068
1188
if cur_revno < start_revno:
1069
1189
# We have gone far enough, but we always add 1 more revision
1070
1190
rev_nos[revision_id] = cur_revno
1084
1204
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
1207
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
include_merges=True):
1208
include_merges=True):
1133
1209
r"""Return the list of revision ids which touch a given file id.
1135
1211
The function filters view_revisions and returns a subset.
1136
1212
This includes the revisions which directly change the file id,
1137
1213
and the revisions which merge these changes. So if the
1138
1214
revision graph is::
1177
1256
# indexing layer. We might consider passing in hints as to the known
1178
1257
# access pattern (sparse/clustered, high success rate/low success
1179
1258
# rate). This particular access is clustered with a low success rate.
1180
get_parent_map = branch.repository.texts.get_parent_map
1181
1259
modified_text_revisions = set()
1182
1260
chunk_size = 1000
1183
for start in xrange(0, len(text_keys), chunk_size):
1261
for start in range(0, len(text_keys), chunk_size):
1184
1262
next_keys = text_keys[start:start + chunk_size]
1185
1263
# Only keep the revision_id portion of the key
1186
1264
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
1291
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1292
"""Reverse revisions by depth.
1257
1294
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,
1295
revision of that depth. There may be no topological justification for this
1259
1296
but it looks much nicer.
1261
1298
# Add a fake revision at start so that we can always attach sub revisions
1312
1353
to indicate which LogRevision attributes it supports:
1314
1355
- 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.
1356
Otherwise the delta attribute may not be populated. The 'delta_format'
1357
attribute describes whether the 'short_status' format (1) or the long
1358
one (2) should be used.
1319
1360
- supports_merge_revisions must be True if this log formatter supports
1320
merge revisions. If not, then only mainline revisions will be passed
1361
merge revisions. If not, then only mainline revisions will be passed
1323
1364
- 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.
1365
The default value is zero meaning display all levels.
1366
This value is only relevant if supports_merge_revisions is True.
1327
1368
- supports_tags must be True if this log formatter supports tags.
1328
Otherwise the tags attribute may not be populated.
1369
Otherwise the tags attribute may not be populated.
1330
1371
- supports_diff must be True if this log formatter supports diffs.
1331
Otherwise the diff attribute may not be populated.
1372
Otherwise the diff attribute may not be populated.
1374
- supports_signatures must be True if this log formatter supports GPG
1333
1377
Plugins can register functions to show custom revision properties using
1334
1378
the properties_handler_registry. The registered function
1335
must respect the following interface description:
1379
must respect the following interface description::
1336
1381
def my_show_properties(properties_dict):
1337
1382
# code that returns a dict {'name':'value'} of the properties
1342
1387
def __init__(self, to_file, show_ids=False, show_timezone='original',
1343
1388
delta_format=None, levels=None, show_advice=False,
1344
to_exact_file=None):
1389
to_exact_file=None, author_list_handler=None):
1345
1390
"""Create a LogFormatter.
1347
1392
:param to_file: the file to output to
1348
:param to_exact_file: if set, gives an output stream to which
1393
:param to_exact_file: if set, gives an output stream to which
1349
1394
non-Unicode diffs are written.
1350
1395
:param show_ids: if True, revision-ids are to be displayed
1351
1396
:param show_timezone: the timezone to use
1355
1400
let the log formatter decide.
1356
1401
:param show_advice: whether to show advice at the end of the
1403
:param author_list_handler: callable generating a list of
1404
authors to display for a given revision
1359
1406
self.to_file = to_file
1360
1407
# '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
1408
# and should not try to decode/encode it to unicode to avoid bug
1362
1410
if to_exact_file is not None:
1363
1411
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
1413
# XXX: somewhat hacky; this assumes it's a codec writer; it's
1414
# better for code that expects to get diffs to pass in the exact
1368
1416
self.to_exact_file = getattr(to_file, 'stream', to_file)
1369
1417
self.show_ids = show_ids
1370
1418
self.show_timezone = show_timezone
1371
1419
if delta_format is None:
1372
1420
# Ensures backward compatibility
1373
delta_format = 2 # long format
1421
delta_format = 2 # long format
1374
1422
self.delta_format = delta_format
1375
1423
self.levels = levels
1376
1424
self._show_advice = show_advice
1377
1425
self._merge_count = 0
1426
self._author_list_handler = author_list_handler
1379
1428
def get_levels(self):
1380
1429
"""Get the number of levels to display or 0 for all."""
1414
1463
def short_author(self, rev):
1415
name, address = config.parse_username(rev.get_apparent_authors()[0])
1464
return self.authors(rev, 'first', short=True, sep=', ')
1466
def authors(self, rev, who, short=False, sep=None):
1467
"""Generate list of authors, taking --authors option into account.
1469
The caller has to specify the name of a author list handler,
1470
as provided by the author list registry, using the ``who``
1471
argument. That name only sets a default, though: when the
1472
user selected a different author list generation using the
1473
``--authors`` command line switch, as represented by the
1474
``author_list_handler`` constructor argument, that value takes
1477
:param rev: The revision for which to generate the list of authors.
1478
:param who: Name of the default handler.
1479
:param short: Whether to shorten names to either name or address.
1480
:param sep: What separator to use for automatic concatenation.
1482
if self._author_list_handler is not None:
1483
# The user did specify --authors, which overrides the default
1484
author_list_handler = self._author_list_handler
1486
# The user didn't specify --authors, so we use the caller's default
1487
author_list_handler = author_list_registry.get(who)
1488
names = author_list_handler(rev)
1490
for i in range(len(names)):
1491
name, address = config.parse_username(names[i])
1497
names = sep.join(names)
1420
1500
def merge_marker(self, revision):
1421
1501
"""Get the merge marker to include in the output or '' if none."""
1513
1595
lines = [_LONG_SEP]
1514
1596
if revision.revno is not None:
1515
1597
lines.append('revno: %s%s' % (revision.revno,
1516
self.merge_marker(revision)))
1598
self.merge_marker(revision)))
1517
1599
if revision.tags:
1518
lines.append('tags: %s' % (', '.join(revision.tags)))
1600
lines.append('tags: %s' % (', '.join(sorted(revision.tags))))
1601
if self.show_ids or revision.revno is None:
1602
lines.append('revision-id: %s' %
1603
(revision.rev.revision_id.decode('utf-8'),))
1519
1604
if self.show_ids:
1520
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1521
1605
for parent_id in revision.rev.parent_ids:
1522
lines.append('parent: %s' % (parent_id,))
1606
lines.append('parent: %s' % (parent_id.decode('utf-8'),))
1523
1607
lines.extend(self.custom_properties(revision.rev))
1525
1609
committer = revision.rev.committer
1526
authors = revision.rev.get_apparent_authors()
1610
authors = self.authors(revision.rev, 'all')
1527
1611
if authors != [committer]:
1528
1612
lines.append('author: %s' % (", ".join(authors),))
1529
1613
lines.append('committer: %s' % (committer,))
1547
1634
to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1548
1635
if revision.delta is not None:
1549
1636
# 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,
1637
from breezy.delta import report_delta
1638
report_delta(to_file, revision.delta, short_status=False,
1552
1639
show_ids=self.show_ids, indent=indent)
1553
1640
if revision.diff is not None:
1554
1641
to_file.write(indent + 'diff:\n')
1598
1685
to_file = self.to_file
1600
1687
if revision.tags:
1601
tags = ' {%s}' % (', '.join(revision.tags))
1688
tags = ' {%s}' % (', '.join(sorted(revision.tags)))
1602
1689
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)
1690
revision.revno or "", self.short_author(
1692
format_date(revision.rev.timestamp,
1693
revision.rev.timezone or 0,
1694
self.show_timezone, date_fmt="%Y-%m-%d",
1696
tags, self.merge_marker(revision)))
1697
self.show_properties(revision.rev, indent + offset)
1698
if self.show_ids or revision.revno is None:
1611
1699
to_file.write(indent + offset + 'revision-id:%s\n'
1612
% (revision.rev.revision_id,))
1700
% (revision.rev.revision_id.decode('utf-8'),))
1613
1701
if not revision.rev.message:
1614
1702
to_file.write(indent + offset + '(no message)\n')
1620
1708
if revision.delta is not None:
1621
1709
# 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,
1710
from breezy.delta import report_delta
1711
report_delta(to_file, revision.delta,
1712
short_status=self.delta_format == 1,
1625
1713
show_ids=self.show_ids, indent=indent + offset)
1626
1714
if revision.diff is not None:
1627
1715
self.show_diff(self.to_exact_file, revision.diff, ' ')
1661
1749
def log_revision(self, revision):
1662
1750
indent = ' ' * revision.merge_depth
1663
1751
self.to_file.write(self.log_string(revision.revno, revision.rev,
1664
self._max_chars, revision.tags, indent))
1752
self._max_chars, revision.tags, indent))
1665
1753
self.to_file.write('\n')
1667
1755
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1668
1756
"""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
1758
:param revno: revision number or None.
1759
Revision numbers counts from 1.
1760
:param rev: revision object
1761
:param max_chars: maximum length of resulting string
1762
:param tags: list of tags or None
1763
:param prefix: string to prefix each line
1764
:return: formatted truncated string
1679
1768
# show revno only when is not None
1680
1769
out.append("%s:" % revno)
1681
out.append(self.truncate(self.short_author(rev), 20))
1770
if max_chars is not None:
1771
out.append(self.truncate(
1772
self.short_author(rev), (max_chars + 3) // 4))
1774
out.append(self.short_author(rev))
1682
1775
out.append(self.date_string(rev))
1683
1776
if len(rev.parent_ids) > 1:
1684
1777
out.append('[merge]')
1686
tag_str = '{%s}' % (', '.join(tags))
1779
tag_str = '{%s}' % (', '.join(sorted(tags)))
1687
1780
out.append(tag_str)
1688
1781
out.append(rev.get_summary())
1689
1782
return self.truncate(prefix + " ".join(out).rstrip('\n'), max_chars)
1703
1796
self.show_timezone,
1704
1797
date_fmt='%Y-%m-%d',
1705
1798
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))
1799
committer_str = self.authors(revision.rev, 'first', sep=', ')
1800
committer_str = committer_str.replace(' <', ' <')
1801
to_file.write('%s %s\n\n' % (date_str, committer_str))
1709
1803
if revision.delta is not None and revision.delta.has_changed():
1710
1804
for c in revision.delta.added + revision.delta.removed + revision.delta.modified:
1712
1806
to_file.write('\t* %s:\n' % (path,))
1713
1807
for c in revision.delta.renamed:
1714
oldpath,newpath = c[:2]
1808
oldpath, newpath = c[:2]
1715
1809
# For renamed files, show both the old and the new path
1716
to_file.write('\t* %s:\n\t* %s:\n' % (oldpath,newpath))
1810
to_file.write('\t* %s:\n\t* %s:\n' % (oldpath, newpath))
1717
1811
to_file.write('\n')
1719
1813
if not revision.rev.message:
1742
1836
return self.get(name)(*args, **kwargs)
1744
1838
def get_default(self, branch):
1745
return self.get(branch.get_config().log_format())
1839
c = branch.get_config_stack()
1840
return self.get(c.get('log_format'))
1748
1843
log_formatter_registry = LogFormatterRegistry()
1751
1846
log_formatter_registry.register('short', ShortLogFormatter,
1752
'Moderately short log format')
1847
'Moderately short log format.')
1753
1848
log_formatter_registry.register('long', LongLogFormatter,
1754
'Detailed log format')
1849
'Detailed log format.')
1755
1850
log_formatter_registry.register('line', LineLogFormatter,
1756
'Log format with one line per revision')
1851
'Log format with one line per revision.')
1757
1852
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1758
'Format used by GNU ChangeLog files')
1853
'Format used by GNU ChangeLog files.')
1761
1856
def register_formatter(name, formatter):
1772
1867
return log_formatter_registry.make_formatter(name, *args, **kwargs)
1773
1868
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)
1869
raise errors.BzrCommandError(
1870
gettext("unknown log formatter: %r") % name)
1873
def author_list_all(rev):
1874
return rev.get_apparent_authors()[:]
1877
def author_list_first(rev):
1878
lst = rev.get_apparent_authors()
1885
def author_list_committer(rev):
1886
return [rev.committer]
1889
author_list_registry = registry.Registry()
1891
author_list_registry.register('all', author_list_all,
1894
author_list_registry.register('first', author_list_first,
1897
author_list_registry.register('committer', author_list_committer,
1783
1901
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1800
1918
# This is the first index which is different between
1802
1920
base_idx = None
1803
for i in xrange(max(len(new_rh),
1921
for i in range(max(len(new_rh), len(old_rh))):
1805
1922
if (len(new_rh) <= i
1806
1923
or len(old_rh) <= i
1807
or new_rh[i] != old_rh[i]):
1924
or new_rh[i] != old_rh[i]):
1811
1928
if base_idx is None:
1812
1929
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
1931
# TODO: It might be nice to do something like show_log
1932
# and show the merged entries. But since this is the
1933
# removed revisions, it shouldn't be as important
1817
1934
if base_idx < len(old_rh):
1818
to_file.write('*'*60)
1935
to_file.write('*' * 60)
1819
1936
to_file.write('\nRemoved Revisions:\n')
1820
1937
for i in range(base_idx, len(old_rh)):
1821
1938
rev = branch.repository.get_revision(old_rh[i])
1822
lr = LogRevision(rev, i+1, 0, None)
1939
lr = LogRevision(rev, i + 1, 0, None)
1823
1940
lf.log_revision(lr)
1824
to_file.write('*'*60)
1941
to_file.write('*' * 60)
1825
1942
to_file.write('\n\n')
1826
1943
if base_idx < len(new_rh):
1827
1944
to_file.write('Added Revisions:\n')
1903
2021
log_format = log_formatter_registry.get_default(branch)
1904
2022
lf = log_format(show_ids=False, to_file=output, show_timezone='original')
1905
2023
if old_history != []:
1906
output.write('*'*60)
2024
output.write('*' * 60)
1907
2025
output.write('\nRemoved Revisions:\n')
1908
2026
show_flat_log(branch.repository, old_history, old_revno, lf)
1909
output.write('*'*60)
2027
output.write('*' * 60)
1910
2028
output.write('\n\n')
1911
2029
if new_history != []:
1912
2030
output.write('Added Revisions:\n')
1913
2031
start_revno = new_revno - len(new_history) + 1
1914
2032
show_log(branch, lf, None, verbose=False, direction='forward',
1915
start_revision=start_revno,)
2033
start_revision=start_revno)
1918
2036
def show_flat_log(repository, history, last_revno, lf):
1923
2041
:param last_revno: The revno of the last revision_id in the history.
1924
2042
:param lf: The log formatter to use.
1926
start_revno = last_revno - len(history) + 1
1927
2044
revisions = repository.get_revisions(history)
1928
2045
for i, rev in enumerate(revisions):
1929
2046
lr = LogRevision(rev, i + last_revno, 0, None)
1930
2047
lf.log_revision(lr)
1933
def _get_info_for_log_files(revisionspec_list, file_list):
2050
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
1934
2051
"""Find file-ids and kinds given a list of files and a revision range.
1936
2053
We search for files at the end of the range. If not found there,
1940
2057
:param file_list: the list of paths given on the command line;
1941
2058
the first of these can be a branch location or a file path,
1942
2059
the remainder must be file paths
2060
:param add_cleanup: When the branch returned is read locked,
2061
an unlock call will be queued to the cleanup.
1943
2062
:return: (branch, info_list, start_rev_info, end_rev_info) where
1944
2063
info_list is a list of (relative_path, file_id, kind) tuples where
1945
2064
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1946
2065
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])
2067
from breezy.builtins import _get_revision_range
2068
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2070
add_cleanup(b.lock_read().unlock)
1951
2071
# XXX: It's damn messy converting a list of paths to relative paths when
1952
2072
# those paths might be deleted ones, they might be on a case-insensitive
1953
2073
# filesystem and/or they might be in silly locations (like another branch).
1957
2077
# case of running log in a nested directory, assuming paths beyond the
1958
2078
# first one haven't been deleted ...
1960
relpaths = [path] + safe_relpath_files(tree, file_list[1:])
2080
relpaths = [path] + tree.safe_relpath_files(file_list[1:])
1962
2082
relpaths = [path] + file_list[1:]
1964
2084
start_rev_info, end_rev_info = _get_revision_range(revisionspec_list, b,
1966
2086
if relpaths in ([], [u'']):
1967
2087
return b, [], start_rev_info, end_rev_info
1968
2088
if start_rev_info is None and end_rev_info is None:
2018
2138
tree1 = b.repository.revision_tree(rev_id)
2019
2139
file_id = tree1.path2id(fp)
2020
kind = _get_kind_for_file_id(tree1, file_id)
2140
kind = _get_kind_for_file_id(tree1, fp, file_id)
2021
2141
info_list.append((fp, file_id, kind))
2022
2142
return b, info_list, start_rev_info, end_rev_info
2025
def _get_kind_for_file_id(tree, file_id):
2145
def _get_kind_for_file_id(tree, path, file_id):
2026
2146
"""Return the kind of a file-id or None if it doesn't exist."""
2027
2147
if file_id is not None:
2028
return tree.kind(file_id)
2148
return tree.kind(path)
2033
2153
properties_handler_registry = registry.Registry()
2035
2155
# Use the properties handlers to print out bug information if available
2036
2158
def _bugs_properties_handler(revision):
2037
if revision.properties.has_key('bugs'):
2160
if 'bugs' in revision.properties:
2038
2161
bug_lines = revision.properties['bugs'].split('\n')
2039
2162
bug_rows = [line.split(' ', 1) for line in bug_lines]
2040
2163
fixed_bug_urls = [row[0] for row in bug_rows if
2041
2164
len(row) > 1 and row[1] == 'fixed']
2165
related_bug_urls = [row[0] for row in bug_rows if
2166
len(row) > 1 and row[1] == 'related']
2043
2167
if fixed_bug_urls:
2044
return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2168
text = ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls))
2169
ret[text] = ' '.join(fixed_bug_urls)
2170
if related_bug_urls:
2171
text = ngettext('related bug', 'related bugs',
2172
len(related_bug_urls))
2173
ret[text] = ' '.join(related_bug_urls)
2047
2177
properties_handler_registry.register('bugs_properties_handler',
2048
2178
_bugs_properties_handler)
added
removed
breezy/log.py
