47
49
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 (
56
60
from warnings import (
60
from .lazy_import import lazy_import
64
from bzrlib.lazy_import import lazy_import
61
65
lazy_import(globals(), """
73
repository as _mod_repository,
69
74
revision as _mod_revision,
71
from breezy.i18n import gettext, ngettext
79
from .osutils import (
84
from bzrlib.osutils import (
81
86
format_date_with_offset_in_original_timezone,
82
get_diff_header_encoding,
83
87
get_terminal_encoding,
91
from bzrlib.symbol_versioning import (
91
from .tree import find_previous_path
94
def find_touching_revisions(repository, last_revision, last_tree, last_path):
97
def find_touching_revisions(branch, file_id):
95
98
"""Yield a description of revisions which affect the file_id.
97
100
Each returned element is (revno, revision_id, description)
102
105
TODO: Perhaps some way to limit this to only particular revisions,
103
106
or to traverse a non-mainline set of revisions?
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)
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
113
119
# now we know how it was last time, and how it is in this revision.
114
120
# are those two states effectively the same or not?
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
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
120
130
elif this_path != last_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
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
128
last_verifier = this_verifier
129
137
last_path = this_path
130
last_tree = this_tree
131
if last_path is None:
141
def _enumerate_history(branch):
144
for rev_id in branch.revision_history():
145
rh.append((revno, rev_id))
136
150
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)
214
209
# Build the request and execute it
215
210
rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
216
start_revision=start_revision, end_revision=end_revision,
217
limit=limit, message_search=search,
218
delta_type=delta_type, diff_type=diff_type)
211
start_revision=start_revision, end_revision=end_revision,
212
limit=limit, message_search=search,
213
delta_type=delta_type, diff_type=diff_type)
219
214
Logger(branch, rqst).show(lf)
222
# Note: This needs to be kept in sync with the defaults in
217
# Note: This needs to be kept this in sync with the defaults in
223
218
# make_log_request_dict() below
224
219
_DEFAULT_REQUEST_PARAMS = {
225
220
'direction': 'reverse',
227
222
'generate_tags': True,
228
223
'exclude_common_ancestry': False,
229
224
'_match_using_deltas': True,
233
228
def make_log_request_dict(direction='reverse', specific_fileids=None,
234
229
start_revision=None, end_revision=None, limit=None,
235
message_search=None, levels=None, generate_tags=True,
230
message_search=None, levels=1, generate_tags=True,
237
232
diff_type=None, _match_using_deltas=True,
238
exclude_common_ancestry=False, match=None,
239
signature=False, omit_merges=False,
233
exclude_common_ancestry=False,
241
235
"""Convenience function for making a logging request dictionary.
281
274
:param _match_using_deltas: a private parameter controlling the
282
275
algorithm used for matching specific_fileids. This parameter
283
may be removed in the future so breezy client code should NOT
276
may be removed in the future so bzrlib client code should NOT
286
279
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
287
280
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]}
309
283
'direction': direction,
310
284
'specific_fileids': specific_fileids,
311
285
'start_revision': start_revision,
312
286
'end_revision': end_revision,
288
'message_search': message_search,
314
289
'levels': levels,
315
290
'generate_tags': generate_tags,
316
291
'delta_type': delta_type,
317
292
'diff_type': diff_type,
318
293
'exclude_common_ancestry': exclude_common_ancestry,
319
'signature': signature,
321
'omit_merges': omit_merges,
322
294
# Add 'private' attributes for features that may be deprecated
323
295
'_match_using_deltas': _match_using_deltas,
327
299
def _apply_log_request_defaults(rqst):
328
300
"""Apply default values to a request dictionary."""
329
result = _DEFAULT_REQUEST_PARAMS.copy()
301
result = _DEFAULT_REQUEST_PARAMS
331
303
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"
356
307
class LogGenerator(object):
357
308
"""A generator of log revisions."""
400
354
# Tweak the LogRequest based on what the LogFormatter can handle.
401
355
# (There's no point generating stuff if the formatter can't display it.)
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()
357
rqst['levels'] = lf.get_levels()
407
358
if not getattr(lf, 'supports_tags', False):
408
359
rqst['generate_tags'] = False
409
360
if not getattr(lf, 'supports_delta', False):
410
361
rqst['delta_type'] = None
411
362
if not getattr(lf, 'supports_diff', False):
412
363
rqst['diff_type'] = None
413
if not getattr(lf, 'supports_signatures', False):
414
rqst['signature'] = False
416
365
# Find and print the interesting revisions
417
366
generator = self._generator_factory(self.branch, rqst)
419
for lr in generator.iter_log_revisions():
421
except errors.GhostRevisionUnusableHere:
422
raise errors.BzrCommandError(
423
gettext('Further revision history missing.'))
367
for lr in generator.iter_log_revisions():
426
371
def _generator_factory(self, branch, rqst):
427
372
"""Make the LogGenerator object to use.
429
374
Subclasses may wish to override this.
431
376
return _DefaultLogGenerator(branch, rqst)
455
400
levels = rqst.get('levels')
456
401
limit = rqst.get('limit')
457
402
diff_type = rqst.get('diff_type')
458
show_signature = rqst.get('signature')
459
omit_merges = rqst.get('omit_merges')
461
404
revision_iterator = self._create_log_revision_iterator()
462
405
for revs in revision_iterator:
463
406
for (rev_id, revno, merge_depth), rev, delta in revs:
464
407
# 0 levels means show everything; merge_depth counts from 0
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)
408
if levels != 0 and merge_depth >= levels:
472
410
if diff_type is None:
475
413
diff = self._format_diff(rev, rev_id, diff_type)
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)
414
yield LogRevision(rev, revno, merge_depth, delta,
415
self.rev_tag_dict.get(rev_id), diff)
485
418
if log_count >= limit:
542
473
# Apply the other filters
543
474
return make_log_rev_iterator(self.branch, view_revisions,
544
rqst.get('delta_type'), rqst.get('match'),
545
file_ids=rqst.get('specific_fileids'),
546
direction=rqst.get('direction'))
475
rqst.get('delta_type'), rqst.get('message_search'),
476
file_ids=rqst.get('specific_fileids'),
477
direction=rqst.get('direction'))
548
479
def _log_revision_iterator_using_per_file_graph(self):
549
480
# Get the base revisions, filtering by the revision range.
557
488
if not isinstance(view_revisions, list):
558
489
view_revisions = list(view_revisions)
559
490
view_revisions = _filter_revisions_touching_file_id(self.branch,
560
rqst.get('specific_fileids')[
562
include_merges=rqst.get('levels') != 1)
491
rqst.get('specific_fileids')[0], view_revisions,
492
include_merges=rqst.get('levels') != 1)
563
493
return make_log_rev_iterator(self.branch, view_revisions,
564
rqst.get('delta_type'), rqst.get('match'))
494
rqst.get('delta_type'), rqst.get('message_search'))
567
497
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
575
505
a list of the same tuples.
577
507
if (exclude_common_ancestry and start_rev_id == end_rev_id):
578
raise errors.BzrCommandError(gettext(
579
'--exclude-common-ancestry requires two different revisions'))
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
580
510
if direction not in ('reverse', 'forward'):
581
raise ValueError(gettext('invalid direction %r') % direction)
582
br_rev_id = branch.last_revision()
583
if br_rev_id == _mod_revision.NULL_REVISION:
511
raise ValueError('invalid direction %r' % direction)
512
br_revno, br_rev_id = branch.last_revision_info()
586
516
if (end_rev_id and start_rev_id == end_rev_id
587
517
and (not generate_merge_revisions
588
518
or not _has_merges(branch, end_rev_id))):
589
519
# If a single revision is requested, check we can handle it
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)))
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)))
622
540
return [(br_rev_id, br_revno, 0)]
624
revno_str = _compute_revno_str(branch, rev_id)
542
revno = branch.revision_id_to_dotted_revno(rev_id)
543
revno_str = '.'.join(str(n) for n in revno)
625
544
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.')
628
561
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
629
562
delayed_graph_generation,
630
563
exclude_common_ancestry=False):
638
571
initial_revisions = []
639
572
if delayed_graph_generation:
641
for rev_id, revno, depth in _linear_view_revisions(
642
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
574
for rev_id, revno, depth in _linear_view_revisions(
575
branch, start_rev_id, end_rev_id):
643
576
if _has_merges(branch, rev_id):
644
577
# The end_rev_id can be nested down somewhere. We need an
645
578
# explicit ancestry check. There is an ambiguity here as we
677
610
# shown naturally, i.e. just like it is for linear logging. We can easily
678
611
# make forward the exact opposite display, but showing the merge revisions
679
612
# indented at the end seems slightly nicer in that case.
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))
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))
685
617
return view_revisions
691
623
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)
709
626
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
710
627
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
711
628
if start_rev_id and 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
629
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
630
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
718
631
if len(start_dotted) == 1 and len(end_dotted) == 1:
719
632
# both on mainline
720
633
return start_dotted[0] <= end_dotted[0]
721
634
elif (len(start_dotted) == 3 and len(end_dotted) == 3 and
722
start_dotted[0:1] == end_dotted[0:1]):
635
start_dotted[0:1] == end_dotted[0:1]):
723
636
# both on same development line
724
637
return start_dotted[2] <= end_dotted[2]
733
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
734
exclude_common_ancestry=False):
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
735
647
"""Calculate a sequence of revisions to view, newest to oldest.
737
649
:param start_rev_id: the lower revision-id
738
650
: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.
741
651
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
742
dotted_revno will be None for ghosts
743
652
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
744
is not found walking the left-hand history
653
is not found walking the left-hand history
655
br_revno, br_rev_id = branch.last_revision_info()
746
656
repo = branch.repository
747
graph = repo.get_graph()
748
657
if start_rev_id is None and end_rev_id is None:
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:
659
for revision_id in repo.iter_reverse_revision_history(br_rev_id):
660
yield revision_id, str(cur_revno), 0
772
br_rev_id = branch.last_revision()
773
663
if end_rev_id is None:
774
664
end_rev_id = br_rev_id
775
665
found_start = start_rev_id is None
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
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
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()
674
yield revision_id, revno_str, 0
677
raise _StartNotLinearAncestor()
800
680
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
841
721
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)
844
743
def _rebase_merge_depth(view_revisions):
845
744
"""Adjust depths upwards so the top level is 0."""
846
745
# If either the first or last revision have a merge_depth of 0, we're done
847
746
if view_revisions and view_revisions[0][2] and view_revisions[-1][2]:
848
min_depth = min([d for r, n, d in view_revisions])
747
min_depth = min([d for r,n,d in view_revisions])
849
748
if min_depth != 0:
850
view_revisions = [(r, n, d - min_depth)
851
for r, n, d in view_revisions]
749
view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
852
750
return view_revisions
855
753
def make_log_rev_iterator(branch, view_revisions, generate_delta, search,
856
file_ids=None, direction='reverse'):
754
file_ids=None, direction='reverse'):
857
755
"""Create a revision iterator for log.
859
757
:param branch: The branch being logged.
870
768
# Convert view_revisions into (view, None, None) groups to fit with
871
769
# the standard interface here.
872
if isinstance(view_revisions, list):
770
if type(view_revisions) == list:
873
771
# A single batch conversion is faster than many incremental ones.
874
772
# As we have all the data, do a batch conversion.
875
773
nones = [None] * len(view_revisions)
876
log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
774
log_rev_iterator = iter([zip(view_revisions, nones, nones)])
879
777
for view in view_revisions:
883
781
# It would be nicer if log adapters were first class objects
884
782
# with custom parameters. This will do for now. IGC 20090127
885
783
if adapter == _make_delta_filter:
886
log_rev_iterator = adapter(
887
branch, generate_delta, search, log_rev_iterator, file_ids,
784
log_rev_iterator = adapter(branch, generate_delta,
785
search, log_rev_iterator, file_ids, direction)
890
log_rev_iterator = adapter(
891
branch, generate_delta, search, log_rev_iterator)
787
log_rev_iterator = adapter(branch, generate_delta,
788
search, log_rev_iterator)
892
789
return log_rev_iterator
895
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
792
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
896
793
"""Create a filtered iterator of log_rev_iterator matching on a regex.
898
795
:param branch: The branch being logged.
899
796
:param generate_delta: Whether to generate a delta for each revision.
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
797
:param search: A user text search string.
904
798
:param log_rev_iterator: An input iterator containing all revisions that
905
799
could be displayed, in lists.
906
800
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
910
804
return 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):
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):
918
811
for revs in log_rev_iterator:
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)
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))
943
819
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
944
fileids=None, direction='reverse'):
820
fileids=None, direction='reverse'):
945
821
"""Add revision deltas to a log iterator if needed.
947
823
:param branch: The branch being logged.
990
866
if delta_type == 'full' and not check_fileids:
991
867
deltas = repository.get_deltas_for_revisions(revisions)
992
for rev, delta in zip(revs, deltas):
868
for rev, delta in izip(revs, deltas):
993
869
new_revs.append((rev[0], rev[1], delta))
995
871
deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
996
for rev, delta in zip(revs, deltas):
872
for rev, delta in izip(revs, deltas):
997
873
if check_fileids:
998
874
if delta is None or not delta.has_changed():
1047
923
for revs in log_rev_iterator:
1048
924
# r = revision_id, n = revno, d = merge depth
1049
925
revision_ids = [view[0] for view, _, _ in revs]
1050
revisions = dict(repository.iter_revisions(revision_ids))
1051
yield [(rev[0], revisions[rev[0][0]], rev[2]) for rev in revs]
926
revisions = repository.get_revisions(revision_ids)
927
revs = [(rev[0], revision, rev[2]) for rev, revision in
928
izip(revs, revisions)]
1054
932
def _make_batch_filter(branch, generate_delta, search, log_rev_iterator):
1088
968
:return: (start_rev_id, end_rev_id) tuple.
970
branch_revno, branch_rev_id = branch.last_revision_info()
1090
971
start_rev_id = 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:
972
if start_revision 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)
1100
983
end_rev_id = None
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:
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)
1113
if branch.last_revision() != _mod_revision.NULL_REVISION:
995
if branch_revno != 0:
1114
996
if (start_rev_id == _mod_revision.NULL_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."))
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.")
1121
1002
return (start_rev_id, end_rev_id)
1171
1052
end_revno = end_revision
1173
1054
if ((start_rev_id == _mod_revision.NULL_REVISION)
1174
or (end_rev_id == _mod_revision.NULL_REVISION)):
1175
raise errors.BzrCommandError(gettext('Logging revision 0 is invalid.'))
1055
or (end_rev_id == _mod_revision.NULL_REVISION)):
1056
raise errors.BzrCommandError('Logging revision 0 is invalid.')
1176
1057
if start_revno > end_revno:
1177
raise errors.BzrCommandError(gettext("Start revision must be older "
1178
"than the end revision."))
1058
raise errors.BzrCommandError("Start revision must be older than "
1059
"the end revision.")
1180
1061
if end_revno < start_revno:
1181
1062
return None, None, None, None
1182
1063
cur_revno = branch_revno
1184
1065
mainline_revs = []
1185
graph = branch.repository.get_graph()
1186
for revision_id in graph.iter_lefthand_ancestry(
1187
branch_last_revision, (_mod_revision.NULL_REVISION,)):
1066
for revision_id in branch.repository.iter_reverse_revision_history(
1067
branch_last_revision):
1188
1068
if cur_revno < start_revno:
1189
1069
# We have gone far enough, but we always add 1 more revision
1190
1070
rev_nos[revision_id] = cur_revno
1204
1084
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
1207
1131
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1208
include_merges=True):
1132
include_merges=True):
1209
1133
r"""Return the list of revision ids which touch a given file id.
1211
1135
The function filters view_revisions and returns a subset.
1212
1136
This includes the revisions which directly change the file id,
1213
1137
and the revisions which merge these changes. So if the
1214
1138
revision graph is::
1256
1177
# indexing layer. We might consider passing in hints as to the known
1257
1178
# access pattern (sparse/clustered, high success rate/low success
1258
1179
# rate). This particular access is clustered with a low success rate.
1180
get_parent_map = branch.repository.texts.get_parent_map
1259
1181
modified_text_revisions = set()
1260
1182
chunk_size = 1000
1261
for start in range(0, len(text_keys), chunk_size):
1183
for start in xrange(0, len(text_keys), chunk_size):
1262
1184
next_keys = text_keys[start:start + chunk_size]
1263
1185
# Only keep the revision_id portion of the key
1264
1186
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
1291
1254
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1292
1255
"""Reverse revisions by depth.
1294
1257
Revisions with a different depth are sorted as a group with the previous
1295
revision of that depth. There may be no topological justification for this
1258
revision of that depth. There may be no topological justification for this,
1296
1259
but it looks much nicer.
1298
1261
# Add a fake revision at start so that we can always attach sub revisions
1353
1312
to indicate which LogRevision attributes it supports:
1355
1314
- supports_delta must be True if this log formatter supports delta.
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.
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.
1360
1319
- supports_merge_revisions must be True if this log formatter supports
1361
merge revisions. If not, then only mainline revisions will be passed
1320
merge revisions. If not, then only mainline revisions will be passed
1364
1323
- preferred_levels is the number of levels this formatter defaults to.
1365
The default value is zero meaning display all levels.
1366
This value is only relevant if supports_merge_revisions is True.
1324
The default value is zero meaning display all levels.
1325
This value is only relevant if supports_merge_revisions is True.
1368
1327
- supports_tags must be True if this log formatter supports tags.
1369
Otherwise the tags attribute may not be populated.
1328
Otherwise the tags attribute may not be populated.
1371
1330
- supports_diff must be True if this log formatter supports diffs.
1372
Otherwise the diff attribute may not be populated.
1374
- supports_signatures must be True if this log formatter supports GPG
1331
Otherwise the diff attribute may not be populated.
1377
1333
Plugins can register functions to show custom revision properties using
1378
1334
the properties_handler_registry. The registered function
1379
must respect the following interface description::
1335
must respect the following interface description:
1381
1336
def my_show_properties(properties_dict):
1382
1337
# code that returns a dict {'name':'value'} of the properties
1387
1342
def __init__(self, to_file, show_ids=False, show_timezone='original',
1388
1343
delta_format=None, levels=None, show_advice=False,
1389
to_exact_file=None, author_list_handler=None):
1344
to_exact_file=None):
1390
1345
"""Create a LogFormatter.
1392
1347
:param to_file: the file to output to
1393
:param to_exact_file: if set, gives an output stream to which
1348
:param to_exact_file: if set, gives an output stream to which
1394
1349
non-Unicode diffs are written.
1395
1350
:param show_ids: if True, revision-ids are to be displayed
1396
1351
:param show_timezone: the timezone to use
1400
1355
let the log formatter decide.
1401
1356
: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
1406
1359
self.to_file = to_file
1407
1360
# 'exact' stream used to show diff, it should print content 'as is'
1408
# and should not try to decode/encode it to unicode to avoid bug
1361
# and should not try to decode/encode it to unicode to avoid bug #328007
1410
1362
if to_exact_file is not None:
1411
1363
self.to_exact_file = to_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
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
1416
1368
self.to_exact_file = getattr(to_file, 'stream', to_file)
1417
1369
self.show_ids = show_ids
1418
1370
self.show_timezone = show_timezone
1419
1371
if delta_format is None:
1420
1372
# Ensures backward compatibility
1421
delta_format = 2 # long format
1373
delta_format = 2 # long format
1422
1374
self.delta_format = delta_format
1423
1375
self.levels = levels
1424
1376
self._show_advice = show_advice
1425
1377
self._merge_count = 0
1426
self._author_list_handler = author_list_handler
1428
1379
def get_levels(self):
1429
1380
"""Get the number of levels to display or 0 for all."""
1463
1414
def short_author(self, rev):
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)
1415
name, address = config.parse_username(rev.get_apparent_authors()[0])
1500
1420
def merge_marker(self, revision):
1501
1421
"""Get the merge marker to include in the output or '' if none."""
1595
1513
lines = [_LONG_SEP]
1596
1514
if revision.revno is not None:
1597
1515
lines.append('revno: %s%s' % (revision.revno,
1598
self.merge_marker(revision)))
1516
self.merge_marker(revision)))
1599
1517
if 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'),))
1518
lines.append('tags: %s' % (', '.join(revision.tags)))
1604
1519
if self.show_ids:
1520
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1605
1521
for parent_id in revision.rev.parent_ids:
1606
lines.append('parent: %s' % (parent_id.decode('utf-8'),))
1522
lines.append('parent: %s' % (parent_id,))
1607
1523
lines.extend(self.custom_properties(revision.rev))
1609
1525
committer = revision.rev.committer
1610
authors = self.authors(revision.rev, 'all')
1526
authors = revision.rev.get_apparent_authors()
1611
1527
if authors != [committer]:
1612
1528
lines.append('author: %s' % (", ".join(authors),))
1613
1529
lines.append('committer: %s' % (committer,))
1634
1547
to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1635
1548
if revision.delta is not None:
1636
1549
# Use the standard status output to display changes
1637
from breezy.delta import report_delta
1638
report_delta(to_file, revision.delta, short_status=False,
1550
from bzrlib.delta import report_delta
1551
report_delta(to_file, revision.delta, short_status=False,
1639
1552
show_ids=self.show_ids, indent=indent)
1640
1553
if revision.diff is not None:
1641
1554
to_file.write(indent + 'diff:\n')
1685
1598
to_file = self.to_file
1687
1600
if revision.tags:
1688
tags = ' {%s}' % (', '.join(sorted(revision.tags)))
1601
tags = ' {%s}' % (', '.join(revision.tags))
1689
1602
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
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:
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)
1699
1611
to_file.write(indent + offset + 'revision-id:%s\n'
1700
% (revision.rev.revision_id.decode('utf-8'),))
1612
% (revision.rev.revision_id,))
1701
1613
if not revision.rev.message:
1702
1614
to_file.write(indent + offset + '(no message)\n')
1708
1620
if revision.delta is not None:
1709
1621
# Use the standard status output to display changes
1710
from breezy.delta import report_delta
1711
report_delta(to_file, revision.delta,
1712
short_status=self.delta_format == 1,
1622
from bzrlib.delta import report_delta
1623
report_delta(to_file, revision.delta,
1624
short_status=self.delta_format==1,
1713
1625
show_ids=self.show_ids, indent=indent + offset)
1714
1626
if revision.diff is not None:
1715
1627
self.show_diff(self.to_exact_file, revision.diff, ' ')
1749
1661
def log_revision(self, revision):
1750
1662
indent = ' ' * revision.merge_depth
1751
1663
self.to_file.write(self.log_string(revision.revno, revision.rev,
1752
self._max_chars, revision.tags, indent))
1664
self._max_chars, revision.tags, indent))
1753
1665
self.to_file.write('\n')
1755
1667
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1756
1668
"""Format log info into one string. Truncate tail of 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
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
1768
1679
# show revno only when is not None
1769
1680
out.append("%s:" % revno)
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))
1681
out.append(self.truncate(self.short_author(rev), 20))
1775
1682
out.append(self.date_string(rev))
1776
1683
if len(rev.parent_ids) > 1:
1777
1684
out.append('[merge]')
1779
tag_str = '{%s}' % (', '.join(sorted(tags)))
1686
tag_str = '{%s}' % (', '.join(tags))
1780
1687
out.append(tag_str)
1781
1688
out.append(rev.get_summary())
1782
1689
return self.truncate(prefix + " ".join(out).rstrip('\n'), max_chars)
1796
1703
self.show_timezone,
1797
1704
date_fmt='%Y-%m-%d',
1798
1705
show_offset=False)
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))
1706
committer_str = revision.rev.get_apparent_authors()[0].replace (' <', ' <')
1707
to_file.write('%s %s\n\n' % (date_str,committer_str))
1803
1709
if revision.delta is not None and revision.delta.has_changed():
1804
1710
for c in revision.delta.added + revision.delta.removed + revision.delta.modified:
1806
1712
to_file.write('\t* %s:\n' % (path,))
1807
1713
for c in revision.delta.renamed:
1808
oldpath, newpath = c[:2]
1714
oldpath,newpath = c[:2]
1809
1715
# For renamed files, show both the old and the new path
1810
to_file.write('\t* %s:\n\t* %s:\n' % (oldpath, newpath))
1716
to_file.write('\t* %s:\n\t* %s:\n' % (oldpath,newpath))
1811
1717
to_file.write('\n')
1813
1719
if not revision.rev.message:
1836
1742
return self.get(name)(*args, **kwargs)
1838
1744
def get_default(self, branch):
1839
c = branch.get_config_stack()
1840
return self.get(c.get('log_format'))
1745
return self.get(branch.get_config().log_format())
1843
1748
log_formatter_registry = LogFormatterRegistry()
1846
1751
log_formatter_registry.register('short', ShortLogFormatter,
1847
'Moderately short log format.')
1752
'Moderately short log format')
1848
1753
log_formatter_registry.register('long', LongLogFormatter,
1849
'Detailed log format.')
1754
'Detailed log format')
1850
1755
log_formatter_registry.register('line', LineLogFormatter,
1851
'Log format with one line per revision.')
1756
'Log format with one line per revision')
1852
1757
log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,
1853
'Format used by GNU ChangeLog files.')
1758
'Format used by GNU ChangeLog files')
1856
1761
def register_formatter(name, formatter):
1867
1772
return log_formatter_registry.make_formatter(name, *args, **kwargs)
1868
1773
except KeyError:
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,
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)
1901
1783
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1918
1800
# This is the first index which is different between
1920
1802
base_idx = None
1921
for i in range(max(len(new_rh), len(old_rh))):
1803
for i in xrange(max(len(new_rh),
1922
1805
if (len(new_rh) <= i
1923
1806
or len(old_rh) <= i
1924
or new_rh[i] != old_rh[i]):
1807
or new_rh[i] != old_rh[i]):
1928
1811
if base_idx is None:
1929
1812
to_file.write('Nothing seems to have changed\n')
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
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
1934
1817
if base_idx < len(old_rh):
1935
to_file.write('*' * 60)
1818
to_file.write('*'*60)
1936
1819
to_file.write('\nRemoved Revisions:\n')
1937
1820
for i in range(base_idx, len(old_rh)):
1938
1821
rev = branch.repository.get_revision(old_rh[i])
1939
lr = LogRevision(rev, i + 1, 0, None)
1822
lr = LogRevision(rev, i+1, 0, None)
1940
1823
lf.log_revision(lr)
1941
to_file.write('*' * 60)
1824
to_file.write('*'*60)
1942
1825
to_file.write('\n\n')
1943
1826
if base_idx < len(new_rh):
1944
1827
to_file.write('Added Revisions:\n')
2021
1903
log_format = log_formatter_registry.get_default(branch)
2022
1904
lf = log_format(show_ids=False, to_file=output, show_timezone='original')
2023
1905
if old_history != []:
2024
output.write('*' * 60)
1906
output.write('*'*60)
2025
1907
output.write('\nRemoved Revisions:\n')
2026
1908
show_flat_log(branch.repository, old_history, old_revno, lf)
2027
output.write('*' * 60)
1909
output.write('*'*60)
2028
1910
output.write('\n\n')
2029
1911
if new_history != []:
2030
1912
output.write('Added Revisions:\n')
2031
1913
start_revno = new_revno - len(new_history) + 1
2032
1914
show_log(branch, lf, None, verbose=False, direction='forward',
2033
start_revision=start_revno)
1915
start_revision=start_revno,)
2036
1918
def show_flat_log(repository, history, last_revno, lf):
2041
1923
:param last_revno: The revno of the last revision_id in the history.
2042
1924
:param lf: The log formatter to use.
1926
start_revno = last_revno - len(history) + 1
2044
1927
revisions = repository.get_revisions(history)
2045
1928
for i, rev in enumerate(revisions):
2046
1929
lr = LogRevision(rev, i + last_revno, 0, None)
2047
1930
lf.log_revision(lr)
2050
def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
1933
def _get_info_for_log_files(revisionspec_list, file_list):
2051
1934
"""Find file-ids and kinds given a list of files and a revision range.
2053
1936
We search for files at the end of the range. If not found there,
2057
1940
:param file_list: the list of paths given on the command line;
2058
1941
the first of these can be a branch location or a file path,
2059
1942
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.
2062
1943
:return: (branch, info_list, start_rev_info, end_rev_info) where
2063
1944
info_list is a list of (relative_path, file_id, kind) tuples where
2064
1945
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2065
1946
branch will be read-locked.
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)
1948
from builtins import _get_revision_range, safe_relpath_files
1949
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2071
1951
# XXX: It's damn messy converting a list of paths to relative paths when
2072
1952
# those paths might be deleted ones, they might be on a case-insensitive
2073
1953
# filesystem and/or they might be in silly locations (like another branch).
2077
1957
# case of running log in a nested directory, assuming paths beyond the
2078
1958
# first one haven't been deleted ...
2080
relpaths = [path] + tree.safe_relpath_files(file_list[1:])
1960
relpaths = [path] + safe_relpath_files(tree, file_list[1:])
2082
1962
relpaths = [path] + file_list[1:]
2084
1964
start_rev_info, end_rev_info = _get_revision_range(revisionspec_list, b,
2086
1966
if relpaths in ([], [u'']):
2087
1967
return b, [], start_rev_info, end_rev_info
2088
1968
if start_rev_info is None and end_rev_info is None:
2138
2018
tree1 = b.repository.revision_tree(rev_id)
2139
2019
file_id = tree1.path2id(fp)
2140
kind = _get_kind_for_file_id(tree1, fp, file_id)
2020
kind = _get_kind_for_file_id(tree1, file_id)
2141
2021
info_list.append((fp, file_id, kind))
2142
2022
return b, info_list, start_rev_info, end_rev_info
2145
def _get_kind_for_file_id(tree, path, file_id):
2025
def _get_kind_for_file_id(tree, file_id):
2146
2026
"""Return the kind of a file-id or None if it doesn't exist."""
2147
2027
if file_id is not None:
2148
return tree.kind(path)
2028
return tree.kind(file_id)
2153
2033
properties_handler_registry = registry.Registry()
2155
2035
# Use the properties handlers to print out bug information if available
2158
2036
def _bugs_properties_handler(revision):
2160
if 'bugs' in revision.properties:
2037
if revision.properties.has_key('bugs'):
2161
2038
bug_lines = revision.properties['bugs'].split('\n')
2162
2039
bug_rows = [line.split(' ', 1) for line in bug_lines]
2163
2040
fixed_bug_urls = [row[0] for row in bug_rows if
2164
2041
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']
2167
2043
if 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)
2044
return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2177
2047
properties_handler_registry.register('bugs_properties_handler',
2178
2048
_bugs_properties_handler)
added
removed
bzrlib/log.py
