49
47
all the changes since the previous revision that touched hello.c.
50
from __future__ import absolute_import
53
from cStringIO import StringIO
54
from itertools import (
60
56
from warnings import (
64
from bzrlib.lazy_import import lazy_import
60
from .lazy_import import lazy_import
65
61
lazy_import(globals(), """
73
repository as _mod_repository,
74
69
revision as _mod_revision,
71
from breezy.i18n import gettext, ngettext
84
from bzrlib.osutils import (
80
from .osutils import (
86
82
format_date_with_offset_in_original_timezone,
83
get_diff_header_encoding,
87
84
get_terminal_encoding,
91
from bzrlib.symbol_versioning import (
97
def find_touching_revisions(branch, file_id):
98
"""Yield a description of revisions which affect the file_id.
93
from .tree import InterTree
96
def find_touching_revisions(repository, last_revision, last_tree, last_path):
97
"""Yield a description of revisions which affect the file.
100
99
Each returned element is (revno, revision_id, description)
105
104
TODO: Perhaps some way to limit this to only particular revisions,
106
105
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
107
last_verifier = last_tree.get_file_verifier(last_path)
108
graph = repository.get_graph()
109
history = list(graph.iter_lefthand_ancestry(last_revision, []))
111
for revision_id in history:
112
this_tree = repository.revision_tree(revision_id)
113
this_intertree = InterTree.get(this_tree, last_tree)
114
this_path = this_intertree.find_source_path(last_path)
119
116
# now we know how it was last time, and how it is in this revision.
120
117
# 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
118
if this_path is not None and last_path is None:
119
yield revno, revision_id, "deleted " + this_path
120
this_verifier = this_tree.get_file_verifier(this_path)
121
elif this_path is None and last_path is not None:
122
yield revno, revision_id, "added " + last_path
130
123
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
124
yield revno, revision_id, ("renamed %s => %s" % (this_path, last_path))
125
this_verifier = this_tree.get_file_verifier(this_path)
127
this_verifier = this_tree.get_file_verifier(this_path)
128
if (this_verifier != last_verifier):
129
yield revno, revision_id, "modified " + this_path
131
last_verifier = this_verifier
137
132
last_path = this_path
141
def _enumerate_history(branch):
144
for rev_id in branch.revision_history():
145
rh.append((revno, rev_id))
133
last_tree = this_tree
134
if last_path is None:
150
139
def show_log(branch,
152
specific_fileid=None,
154
142
direction='reverse',
155
143
start_revision=None,
156
144
end_revision=None,
160
148
"""Write out human-readable log of commits to this branch.
162
150
This function is being retained for backwards compatibility but
179
164
:param end_revision: If not None, only show revisions <= end_revision
181
:param search: If not None, only show revisions with matching commit
184
166
:param limit: If set, shows only 'limit' revisions, all revisions are shown
187
169
:param show_diff: If True, output a diff after each revision.
171
:param match: Dictionary of search lists to use when matching revision
189
# Convert old-style parameters to new-style parameters
190
if specific_fileid is not None:
191
file_ids = [specific_fileid]
196
delta_type = 'partial'
200
177
delta_type = None
203
diff_type = 'partial'
183
if isinstance(start_revision, int):
185
start_revision = revisionspec.RevisionInfo(branch, start_revision)
186
except (errors.NoSuchRevision, errors.RevnoOutOfBounds):
187
raise errors.InvalidRevisionNumber(start_revision)
189
if isinstance(end_revision, int):
191
end_revision = revisionspec.RevisionInfo(branch, end_revision)
192
except (errors.NoSuchRevision, errors.RevnoOutOfBounds):
193
raise errors.InvalidRevisionNumber(end_revision)
195
if end_revision is not None and end_revision.revno == 0:
196
raise errors.InvalidRevisionNumber(end_revision.revno)
209
198
# Build the request and execute it
210
rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
199
rqst = make_log_request_dict(
211
201
start_revision=start_revision, end_revision=end_revision,
212
limit=limit, message_search=search,
213
delta_type=delta_type, diff_type=diff_type)
202
limit=limit, delta_type=delta_type, diff_type=diff_type)
214
203
Logger(branch, rqst).show(lf)
217
# Note: This needs to be kept this in sync with the defaults in
206
# Note: This needs to be kept in sync with the defaults in
218
207
# make_log_request_dict() below
219
208
_DEFAULT_REQUEST_PARAMS = {
220
209
'direction': 'reverse',
222
211
'generate_tags': True,
223
212
'exclude_common_ancestry': False,
224
213
'_match_using_deltas': True,
228
def make_log_request_dict(direction='reverse', specific_fileids=None,
217
def make_log_request_dict(direction='reverse', specific_files=None,
229
218
start_revision=None, end_revision=None, limit=None,
230
message_search=None, levels=1, generate_tags=True,
219
message_search=None, levels=None, generate_tags=True,
232
221
diff_type=None, _match_using_deltas=True,
233
exclude_common_ancestry=False,
222
exclude_common_ancestry=False, match=None,
223
signature=False, omit_merges=False,
235
225
"""Convenience function for making a logging request dictionary.
257
247
matching commit messages
259
249
:param levels: the number of levels of revisions to
260
generate; 1 for just the mainline; 0 for all levels.
250
generate; 1 for just the mainline; 0 for all levels, or None for
262
253
:param generate_tags: If True, include tags for matched revisions.
264
255
:param delta_type: Either 'full', 'partial' or None.
265
256
'full' means generate the complete delta - adds/deletes/modifies/etc;
266
'partial' means filter the delta using specific_fileids;
257
'partial' means filter the delta using specific_files;
267
258
None means do not generate any delta.
269
260
:param diff_type: Either 'full', 'partial' or None.
270
261
'full' means generate the complete diff - adds/deletes/modifies/etc;
271
'partial' means filter the diff using specific_fileids;
262
'partial' means filter the diff using specific_files;
272
263
None means do not generate any diff.
274
265
:param _match_using_deltas: a private parameter controlling the
275
algorithm used for matching specific_fileids. This parameter
276
may be removed in the future so bzrlib client code should NOT
266
algorithm used for matching specific_files. This parameter
267
may be removed in the future so breezy client code should NOT
279
270
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
271
range operator or as a graph difference.
273
:param signature: show digital signature information
275
:param match: Dictionary of list of search strings to use when filtering
276
revisions. Keys can be 'message', 'author', 'committer', 'bugs' or
277
the empty string to match any of the preceding properties.
279
:param omit_merges: If True, commits with more than one parent are
283
# Take care of old style message_search parameter
286
if 'message' in match:
287
match['message'].append(message_search)
289
match['message'] = [message_search]
291
match = {'message': [message_search]}
283
293
'direction': direction,
284
'specific_fileids': specific_fileids,
294
'specific_files': specific_files,
285
295
'start_revision': start_revision,
286
296
'end_revision': end_revision,
288
'message_search': message_search,
289
298
'levels': levels,
290
299
'generate_tags': generate_tags,
291
300
'delta_type': delta_type,
292
301
'diff_type': diff_type,
293
302
'exclude_common_ancestry': exclude_common_ancestry,
303
'signature': signature,
305
'omit_merges': omit_merges,
294
306
# Add 'private' attributes for features that may be deprecated
295
307
'_match_using_deltas': _match_using_deltas,
354
384
# Tweak the LogRequest based on what the LogFormatter can handle.
355
385
# (There's no point generating stuff if the formatter can't display it.)
357
rqst['levels'] = lf.get_levels()
387
if rqst['levels'] is None or lf.get_levels() > rqst['levels']:
388
# user didn't specify levels, use whatever the LF can handle:
389
rqst['levels'] = lf.get_levels()
358
391
if not getattr(lf, 'supports_tags', False):
359
392
rqst['generate_tags'] = False
360
393
if not getattr(lf, 'supports_delta', False):
361
394
rqst['delta_type'] = None
362
395
if not getattr(lf, 'supports_diff', False):
363
396
rqst['diff_type'] = None
397
if not getattr(lf, 'supports_signatures', False):
398
rqst['signature'] = False
365
400
# Find and print the interesting revisions
366
401
generator = self._generator_factory(self.branch, rqst)
367
for lr in generator.iter_log_revisions():
403
for lr in generator.iter_log_revisions():
405
except errors.GhostRevisionUnusableHere:
406
raise errors.CommandError(
407
gettext('Further revision history missing.'))
371
410
def _generator_factory(self, branch, rqst):
372
411
"""Make the LogGenerator object to use.
374
413
Subclasses may wish to override this.
376
return _DefaultLogGenerator(branch, rqst)
415
return _DefaultLogGenerator(branch, **rqst)
418
def _log_revision_iterator_using_per_file_graph(
419
branch, delta_type, match, levels, path, start_rev_id, end_rev_id,
420
direction, exclude_common_ancestry):
421
# Get the base revisions, filtering by the revision range.
422
# Note that we always generate the merge revisions because
423
# filter_revisions_touching_path() requires them ...
424
view_revisions = _calc_view_revisions(
425
branch, start_rev_id, end_rev_id,
426
direction, generate_merge_revisions=True,
427
exclude_common_ancestry=exclude_common_ancestry)
428
if not isinstance(view_revisions, list):
429
view_revisions = list(view_revisions)
430
view_revisions = _filter_revisions_touching_path(
431
branch, path, view_revisions,
432
include_merges=levels != 1)
433
return make_log_rev_iterator(
434
branch, view_revisions, delta_type, match)
437
def _log_revision_iterator_using_delta_matching(
438
branch, delta_type, match, levels, specific_files, start_rev_id, end_rev_id,
439
direction, exclude_common_ancestry, limit):
440
# Get the base revisions, filtering by the revision range
441
generate_merge_revisions = levels != 1
442
delayed_graph_generation = not specific_files and (
443
limit or start_rev_id or end_rev_id)
444
view_revisions = _calc_view_revisions(
445
branch, start_rev_id, end_rev_id,
447
generate_merge_revisions=generate_merge_revisions,
448
delayed_graph_generation=delayed_graph_generation,
449
exclude_common_ancestry=exclude_common_ancestry)
451
# Apply the other filters
452
return make_log_rev_iterator(branch, view_revisions,
454
files=specific_files,
458
def _format_diff(branch, rev, diff_type, files=None):
461
:param branch: Branch object
462
:param rev: Revision object
463
:param diff_type: Type of diff to generate
464
:param files: List of files to generate diff for (or None for all)
466
repo = branch.repository
467
if len(rev.parent_ids) == 0:
468
ancestor_id = _mod_revision.NULL_REVISION
470
ancestor_id = rev.parent_ids[0]
471
tree_1 = repo.revision_tree(ancestor_id)
472
tree_2 = repo.revision_tree(rev.revision_id)
473
if diff_type == 'partial' and files is not None:
474
specific_files = files
476
specific_files = None
478
path_encoding = get_diff_header_encoding()
479
diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
480
new_label='', path_encoding=path_encoding)
379
484
class _StartNotLinearAncestor(Exception):
383
488
class _DefaultLogGenerator(LogGenerator):
384
489
"""The default generator of log revisions."""
386
def __init__(self, branch, rqst):
492
self, branch, levels=None, limit=None, diff_type=None,
493
delta_type=None, show_signature=None, omit_merges=None,
494
generate_tags=None, specific_files=None, match=None,
495
start_revision=None, end_revision=None, direction=None,
496
exclude_common_ancestry=None, _match_using_deltas=None,
387
498
self.branch = branch
389
if rqst.get('generate_tags') and branch.supports_tags():
501
self.diff_type = diff_type
502
self.delta_type = delta_type
503
self.show_signature = signature
504
self.omit_merges = omit_merges
505
self.specific_files = specific_files
507
self.start_revision = start_revision
508
self.end_revision = end_revision
509
self.direction = direction
510
self.exclude_common_ancestry = exclude_common_ancestry
511
self._match_using_deltas = _match_using_deltas
512
if generate_tags and branch.supports_tags():
390
513
self.rev_tag_dict = branch.tags.get_reverse_tag_dict()
392
515
self.rev_tag_dict = {}
397
520
:return: An iterator yielding LogRevision objects.
400
levels = rqst.get('levels')
401
limit = rqst.get('limit')
402
diff_type = rqst.get('diff_type')
404
523
revision_iterator = self._create_log_revision_iterator()
405
524
for revs in revision_iterator:
406
525
for (rev_id, revno, merge_depth), rev, delta in revs:
407
526
# 0 levels means show everything; merge_depth counts from 0
408
if levels != 0 and merge_depth >= levels:
410
if diff_type is None:
527
if (self.levels != 0 and merge_depth is not None and
528
merge_depth >= self.levels):
530
if self.omit_merges and len(rev.parent_ids) > 1:
533
raise errors.GhostRevisionUnusableHere(rev_id)
534
if self.diff_type is None:
413
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)
538
self.branch, rev, self.diff_type,
540
if self.show_signature:
541
signature = format_signature_validity(rev_id, self.branch)
545
rev, revno, merge_depth, delta,
546
self.rev_tag_dict.get(rev_id), diff, signature)
418
if log_count >= limit:
549
if log_count >= self.limit:
421
def _format_diff(self, rev, rev_id, diff_type):
422
repo = self.branch.repository
423
if len(rev.parent_ids) == 0:
424
ancestor_id = _mod_revision.NULL_REVISION
426
ancestor_id = rev.parent_ids[0]
427
tree_1 = repo.revision_tree(ancestor_id)
428
tree_2 = repo.revision_tree(rev_id)
429
file_ids = self.rqst.get('specific_fileids')
430
if diff_type == 'partial' and file_ids is not None:
431
specific_files = [tree_2.id2path(id) for id in file_ids]
433
specific_files = None
435
diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
439
552
def _create_log_revision_iterator(self):
440
553
"""Create a revision iterator for log.
442
555
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
445
self.start_rev_id, self.end_rev_id = _get_revision_limits(
446
self.branch, self.rqst.get('start_revision'),
447
self.rqst.get('end_revision'))
448
if self.rqst.get('_match_using_deltas'):
449
return self._log_revision_iterator_using_delta_matching()
558
start_rev_id, end_rev_id = _get_revision_limits(
559
self.branch, self.start_revision, self.end_revision)
560
if self._match_using_deltas:
561
return _log_revision_iterator_using_delta_matching(
563
delta_type=self.delta_type,
566
specific_files=self.specific_files,
567
start_rev_id=start_rev_id, end_rev_id=end_rev_id,
568
direction=self.direction,
569
exclude_common_ancestry=self.exclude_common_ancestry,
451
572
# We're using the per-file-graph algorithm. This scales really
452
573
# well but only makes sense if there is a single file and it's
453
574
# not a directory
454
file_count = len(self.rqst.get('specific_fileids'))
575
file_count = len(self.specific_files)
455
576
if file_count != 1:
456
raise BzrError("illegal LogRequest: must match-using-deltas "
577
raise errors.BzrError(
578
"illegal LogRequest: must match-using-deltas "
457
579
"when logging %d files" % file_count)
458
return self._log_revision_iterator_using_per_file_graph()
460
def _log_revision_iterator_using_delta_matching(self):
461
# Get the base revisions, filtering by the revision range
463
generate_merge_revisions = rqst.get('levels') != 1
464
delayed_graph_generation = not rqst.get('specific_fileids') and (
465
rqst.get('limit') or self.start_rev_id or self.end_rev_id)
466
view_revisions = _calc_view_revisions(
467
self.branch, self.start_rev_id, self.end_rev_id,
468
rqst.get('direction'),
469
generate_merge_revisions=generate_merge_revisions,
470
delayed_graph_generation=delayed_graph_generation,
471
exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
473
# Apply the other filters
474
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'))
479
def _log_revision_iterator_using_per_file_graph(self):
480
# Get the base revisions, filtering by the revision range.
481
# Note that we always generate the merge revisions because
482
# filter_revisions_touching_file_id() requires them ...
484
view_revisions = _calc_view_revisions(
485
self.branch, self.start_rev_id, self.end_rev_id,
486
rqst.get('direction'), generate_merge_revisions=True,
487
exclude_common_ancestry=rqst.get('exclude_common_ancestry'))
488
if not isinstance(view_revisions, list):
489
view_revisions = list(view_revisions)
490
view_revisions = _filter_revisions_touching_file_id(self.branch,
491
rqst.get('specific_fileids')[0], view_revisions,
492
include_merges=rqst.get('levels') != 1)
493
return make_log_rev_iterator(self.branch, view_revisions,
494
rqst.get('delta_type'), rqst.get('message_search'))
580
return _log_revision_iterator_using_per_file_graph(
582
delta_type=self.delta_type,
585
path=self.specific_files[0],
586
start_rev_id=start_rev_id, end_rev_id=end_rev_id,
587
direction=self.direction,
588
exclude_common_ancestry=self.exclude_common_ancestry
497
592
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
505
600
a list of the same tuples.
507
602
if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
603
raise errors.CommandError(gettext(
604
'--exclude-common-ancestry requires two different revisions'))
510
605
if direction not in ('reverse', 'forward'):
511
raise ValueError('invalid direction %r' % direction)
512
br_revno, br_rev_id = branch.last_revision_info()
606
raise ValueError(gettext('invalid direction %r') % direction)
607
br_rev_id = branch.last_revision()
608
if br_rev_id == _mod_revision.NULL_REVISION:
516
611
if (end_rev_id and start_rev_id == end_rev_id
517
612
and (not generate_merge_revisions
518
613
or not _has_merges(branch, end_rev_id))):
519
614
# 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)))
615
return _generate_one_revision(branch, end_rev_id, br_rev_id,
617
if not generate_merge_revisions:
619
# If we only want to see linear revisions, we can iterate ...
620
iter_revs = _linear_view_revisions(
621
branch, start_rev_id, end_rev_id,
622
exclude_common_ancestry=exclude_common_ancestry)
623
# If a start limit was given and it's not obviously an
624
# ancestor of the end limit, check it before outputting anything
625
if (direction == 'forward'
626
or (start_rev_id and not _is_obvious_ancestor(
627
branch, start_rev_id, end_rev_id))):
628
iter_revs = list(iter_revs)
629
if direction == 'forward':
630
iter_revs = reversed(iter_revs)
632
except _StartNotLinearAncestor:
633
# Switch to the slower implementation that may be able to find a
634
# non-obvious ancestor out of the left-hand history.
636
iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,
637
direction, delayed_graph_generation,
638
exclude_common_ancestry)
639
if direction == 'forward':
640
iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))
540
647
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)
649
revno_str = _compute_revno_str(branch, rev_id)
544
650
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
653
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
654
delayed_graph_generation,
563
655
exclude_common_ancestry=False):
623
716
return len(parents) > 1
719
def _compute_revno_str(branch, rev_id):
720
"""Compute the revno string from a rev_id.
722
:return: The revno string, or None if the revision is not in the supplied
726
revno = branch.revision_id_to_dotted_revno(rev_id)
727
except errors.NoSuchRevision:
728
# The revision must be outside of this branch
731
return '.'.join(str(n) for n in revno)
626
734
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
735
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
628
736
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)
738
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
739
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
740
except errors.NoSuchRevision:
741
# one or both is not in the branch; not obvious
631
743
if len(start_dotted) == 1 and len(end_dotted) == 1:
632
744
# both on mainline
633
745
return start_dotted[0] <= end_dotted[0]
634
746
elif (len(start_dotted) == 3 and len(end_dotted) == 3 and
635
start_dotted[0:1] == end_dotted[0:1]):
747
start_dotted[0:1] == end_dotted[0:1]):
636
748
# both on same development line
637
749
return start_dotted[2] <= end_dotted[2]
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
758
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
759
exclude_common_ancestry=False):
647
760
"""Calculate a sequence of revisions to view, newest to oldest.
649
762
:param start_rev_id: the lower revision-id
650
763
:param end_rev_id: the upper revision-id
764
:param exclude_common_ancestry: Whether the start_rev_id should be part of
765
the iterated revisions.
651
766
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
767
dotted_revno will be None for ghosts
652
768
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
is not found walking the left-hand history
769
is not found walking the left-hand history
655
br_revno, br_rev_id = branch.last_revision_info()
656
771
repo = branch.repository
772
graph = repo.get_graph()
657
773
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
774
if branch._format.stores_revno() or \
775
config.GlobalStack().get('calculate_revnos'):
777
br_revno, br_rev_id = branch.last_revision_info()
778
except errors.GhostRevisionsHaveNoRevno:
779
br_rev_id = branch.last_revision()
784
br_rev_id = branch.last_revision()
787
graph_iter = graph.iter_lefthand_ancestry(br_rev_id,
788
(_mod_revision.NULL_REVISION,))
791
revision_id = next(graph_iter)
792
except errors.RevisionNotPresent as e:
794
yield e.revision_id, None, None
796
except StopIteration:
799
yield revision_id, str(cur_revno) if cur_revno is not None else None, 0
800
if cur_revno is not None:
803
br_rev_id = branch.last_revision()
663
804
if end_rev_id is None:
664
805
end_rev_id = br_rev_id
665
806
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
807
graph_iter = graph.iter_lefthand_ancestry(end_rev_id,
808
(_mod_revision.NULL_REVISION,))
811
revision_id = next(graph_iter)
812
except StopIteration:
814
except errors.RevisionNotPresent as e:
816
yield e.revision_id, None, None
674
yield revision_id, revno_str, 0
677
raise _StartNotLinearAncestor()
819
revno_str = _compute_revno_str(branch, revision_id)
820
if not found_start and revision_id == start_rev_id:
821
if not exclude_common_ancestry:
822
yield revision_id, revno_str, 0
826
yield revision_id, revno_str, 0
828
raise _StartNotLinearAncestor()
680
831
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
721
872
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
875
def _rebase_merge_depth(view_revisions):
744
876
"""Adjust depths upwards so the top level is 0."""
745
877
# If either the first or last revision have a merge_depth of 0, we're done
746
878
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])
879
min_depth = min([d for r, n, d in view_revisions])
748
880
if min_depth != 0:
749
view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
881
view_revisions = [(r, n, d - min_depth)
882
for r, n, d in view_revisions]
750
883
return view_revisions
753
886
def make_log_rev_iterator(branch, view_revisions, generate_delta, search,
754
file_ids=None, direction='reverse'):
887
files=None, direction='reverse'):
755
888
"""Create a revision iterator for log.
757
890
:param branch: The branch being logged.
759
892
:param generate_delta: Whether to generate a delta for each revision.
760
893
Permitted values are None, 'full' and 'partial'.
761
894
:param search: A user text search string.
762
:param file_ids: If non empty, only revisions matching one or more of
763
the file-ids are to be kept.
895
:param files: If non empty, only revisions matching one or more of
896
the files are to be kept.
764
897
:param direction: the direction in which view_revisions is sorted
765
898
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
768
901
# Convert view_revisions into (view, None, None) groups to fit with
769
902
# the standard interface here.
770
if type(view_revisions) == list:
903
if isinstance(view_revisions, list):
771
904
# A single batch conversion is faster than many incremental ones.
772
905
# As we have all the data, do a batch conversion.
773
906
nones = [None] * len(view_revisions)
774
log_rev_iterator = iter([zip(view_revisions, nones, nones)])
907
log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
777
910
for view in view_revisions:
781
914
# It would be nicer if log adapters were first class objects
782
915
# with custom parameters. This will do for now. IGC 20090127
783
916
if adapter == _make_delta_filter:
784
log_rev_iterator = adapter(branch, generate_delta,
785
search, log_rev_iterator, file_ids, direction)
917
log_rev_iterator = adapter(
918
branch, generate_delta, search, log_rev_iterator, files,
787
log_rev_iterator = adapter(branch, generate_delta,
788
search, log_rev_iterator)
921
log_rev_iterator = adapter(
922
branch, generate_delta, search, log_rev_iterator)
789
923
return log_rev_iterator
792
def _make_search_filter(branch, generate_delta, search, log_rev_iterator):
926
def _make_search_filter(branch, generate_delta, match, log_rev_iterator):
793
927
"""Create a filtered iterator of log_rev_iterator matching on a regex.
795
929
:param branch: The branch being logged.
796
930
:param generate_delta: Whether to generate a delta for each revision.
797
:param search: A user text search string.
931
:param match: A dictionary with properties as keys and lists of strings
932
as values. To match, a revision may match any of the supplied strings
933
within a single property but must match at least one string for each
798
935
:param log_rev_iterator: An input iterator containing all revisions that
799
936
could be displayed, in lists.
800
937
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
804
941
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):
942
# Use lazy_compile so mapping to InvalidPattern error occurs.
943
searchRE = [(k, [lazy_regex.lazy_compile(x, re.IGNORECASE) for x in v])
944
for k, v in match.items()]
945
return _filter_re(searchRE, log_rev_iterator)
948
def _filter_re(searchRE, log_rev_iterator):
811
949
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))
950
new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]
955
def _match_filter(searchRE, rev):
957
'message': (rev.message,),
958
'committer': (rev.committer,),
959
'author': (rev.get_apparent_authors()),
960
'bugs': list(rev.iter_bugs())
962
strings[''] = [item for inner_list in strings.values()
963
for item in inner_list]
964
for k, v in searchRE:
965
if k in strings and not _match_any_filter(strings[k], v):
970
def _match_any_filter(strings, res):
971
return any(r.search(s) for r in res for s in strings)
819
974
def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,
820
fileids=None, direction='reverse'):
975
files=None, direction='reverse'):
821
976
"""Add revision deltas to a log iterator if needed.
823
978
:param branch: The branch being logged.
826
981
:param search: A user text search string.
827
982
:param log_rev_iterator: An input iterator containing all revisions that
828
983
could be displayed, in lists.
829
:param fileids: If non empty, only revisions matching one or more of
830
the file-ids are to be kept.
984
:param files: If non empty, only revisions matching one or more of
985
the files are to be kept.
831
986
:param direction: the direction in which view_revisions is sorted
832
987
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
835
if not generate_delta and not fileids:
990
if not generate_delta and not files:
836
991
return log_rev_iterator
837
992
return _generate_deltas(branch.repository, log_rev_iterator,
838
generate_delta, fileids, direction)
841
def _generate_deltas(repository, log_rev_iterator, delta_type, fileids,
993
generate_delta, files, direction)
996
def _generate_deltas(repository, log_rev_iterator, delta_type, files,
843
998
"""Create deltas for each batch of revisions in log_rev_iterator.
845
1000
If we're only generating deltas for the sake of filtering against
846
file-ids, we stop generating deltas once all file-ids reach the
1001
files, we stop generating deltas once all files reach the
847
1002
appropriate life-cycle point. If we're receiving data newest to
848
1003
oldest, then that life-cycle point is 'add', otherwise it's 'remove'.
850
check_fileids = fileids is not None and len(fileids) > 0
852
fileid_set = set(fileids)
1005
check_files = files is not None and len(files) > 0
1007
file_set = set(files)
853
1008
if direction == 'reverse':
856
1011
stop_on = 'remove'
859
1014
for revs in log_rev_iterator:
860
# If we were matching against fileids and we've run out,
1015
# If we were matching against files and we've run out,
861
1016
# there's nothing left to do
862
if check_fileids and not fileid_set:
1017
if check_files and not file_set:
864
1019
revisions = [rev[1] for rev in revs]
866
if delta_type == 'full' and not check_fileids:
867
deltas = repository.get_deltas_for_revisions(revisions)
868
for rev, delta in izip(revs, deltas):
1021
if delta_type == 'full' and not check_files:
1022
deltas = repository.get_revision_deltas(revisions)
1023
for rev, delta in zip(revs, deltas):
869
1024
new_revs.append((rev[0], rev[1], delta))
871
deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
872
for rev, delta in izip(revs, deltas):
1026
deltas = repository.get_revision_deltas(
1027
revisions, specific_files=file_set)
1028
for rev, delta in zip(revs, deltas):
874
1030
if delta is None or not delta.has_changed():
877
_update_fileids(delta, fileid_set, stop_on)
1033
_update_files(delta, file_set, stop_on)
878
1034
if delta_type is None:
880
1036
elif delta_type == 'full':
894
def _update_fileids(delta, fileids, stop_on):
895
"""Update the set of file-ids to search based on file lifecycle events.
897
:param fileids: a set of fileids to update
898
:param stop_on: either 'add' or 'remove' - take file-ids out of the
899
fileids set once their add or remove entry is detected respectively
1050
def _update_files(delta, files, stop_on):
1051
"""Update the set of files to search based on file lifecycle events.
1053
:param files: a set of files to update
1054
:param stop_on: either 'add' or 'remove' - take files out of the
1055
files set once their add or remove entry is detected respectively
901
1057
if stop_on == 'add':
902
1058
for item in delta.added:
903
if item[1] in fileids:
904
fileids.remove(item[1])
1059
if item.path[1] in files:
1060
files.remove(item.path[1])
1061
for item in delta.copied + delta.renamed:
1062
if item.path[1] in files:
1063
files.remove(item.path[1])
1064
files.add(item.path[0])
1065
if item.kind[1] == 'directory':
1066
for path in list(files):
1067
if is_inside(item.path[1], path):
1069
files.add(item.path[0] + path[len(item.path[1]):])
905
1070
elif stop_on == 'delete':
906
1071
for item in delta.removed:
907
if item[1] in fileids:
908
fileids.remove(item[1])
1072
if item.path[0] in files:
1073
files.remove(item.path[0])
1074
for item in delta.copied + delta.renamed:
1075
if item.path[0] in files:
1076
files.remove(item.path[0])
1077
files.add(item.path[1])
1078
if item.kind[0] == 'directory':
1079
for path in list(files):
1080
if is_inside(item.path[0], path):
1082
files.add(item.path[1] + path[len(item.path[0]):])
911
1085
def _make_revision_objects(branch, generate_delta, search, log_rev_iterator):
955
1126
def _get_revision_limits(branch, start_revision, end_revision):
956
1127
"""Get and check revision limits.
958
:param branch: The branch containing the revisions.
960
:param start_revision: The first revision to be logged.
961
For backwards compatibility this may be a mainline integer revno,
962
but for merge revision support a RevisionInfo is expected.
964
:param end_revision: The last revision to be logged.
965
For backwards compatibility this may be a mainline integer revno,
966
but for merge revision support a RevisionInfo is expected.
1129
:param branch: The branch containing the revisions.
1131
:param start_revision: The first revision to be logged, as a RevisionInfo.
1133
:param end_revision: The last revision to be logged, as a RevisionInfo
968
1135
:return: (start_rev_id, end_rev_id) tuple.
970
branch_revno, branch_rev_id = branch.last_revision_info()
971
1137
start_rev_id = None
972
if start_revision is None:
1139
if start_revision is not None:
1140
if not isinstance(start_revision, revisionspec.RevisionInfo):
1141
raise TypeError(start_revision)
1142
start_rev_id = start_revision.rev_id
1143
start_revno = start_revision.revno
1144
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
1147
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)
1149
if end_revision is not None:
1150
if not isinstance(end_revision, revisionspec.RevisionInfo):
1151
raise TypeError(start_revision)
1152
end_rev_id = end_revision.rev_id
1153
end_revno = end_revision.revno
995
if branch_revno != 0:
1155
if branch.last_revision() != _mod_revision.NULL_REVISION:
996
1156
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.")
1157
or end_rev_id == _mod_revision.NULL_REVISION):
1158
raise errors.CommandError(
1159
gettext('Logging revision 0 is invalid.'))
1160
if end_revno is not None and start_revno > end_revno:
1161
raise errors.CommandError(
1162
gettext("Start revision must be older than the end revision."))
1002
1163
return (start_rev_id, end_rev_id)
1084
1246
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
def _filter_revisions_touching_file_id(branch, file_id, view_revisions,
1132
include_merges=True):
1133
r"""Return the list of revision ids which touch a given file id.
1249
def _filter_revisions_touching_path(branch, path, view_revisions,
1250
include_merges=True):
1251
r"""Return the list of revision ids which touch a given path.
1135
1253
The function filters view_revisions and returns a subset.
1136
This includes the revisions which directly change the file id,
1254
This includes the revisions which directly change the path,
1137
1255
and the revisions which merge these changes. So if the
1138
1256
revision graph is::
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
1335
def reverse_by_depth(merge_sorted_revisions, _depth=0):
1255
1336
"""Reverse revisions by depth.
1257
1338
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,
1339
revision of that depth. There may be no topological justification for this
1259
1340
but it looks much nicer.
1261
1342
# Add a fake revision at start so that we can always attach sub revisions
1312
1397
to indicate which LogRevision attributes it supports:
1314
1399
- 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.
1400
Otherwise the delta attribute may not be populated. The 'delta_format'
1401
attribute describes whether the 'short_status' format (1) or the long
1402
one (2) should be used.
1319
1404
- supports_merge_revisions must be True if this log formatter supports
1320
merge revisions. If not, then only mainline revisions will be passed
1405
merge revisions. If not, then only mainline revisions will be passed
1323
1408
- 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.
1409
The default value is zero meaning display all levels.
1410
This value is only relevant if supports_merge_revisions is True.
1327
1412
- supports_tags must be True if this log formatter supports tags.
1328
Otherwise the tags attribute may not be populated.
1413
Otherwise the tags attribute may not be populated.
1330
1415
- supports_diff must be True if this log formatter supports diffs.
1331
Otherwise the diff attribute may not be populated.
1416
Otherwise the diff attribute may not be populated.
1418
- supports_signatures must be True if this log formatter supports GPG
1333
1421
Plugins can register functions to show custom revision properties using
1334
1422
the properties_handler_registry. The registered function
1335
must respect the following interface description:
1423
must respect the following interface description::
1336
1425
def my_show_properties(properties_dict):
1337
1426
# code that returns a dict {'name':'value'} of the properties
1355
1444
let the log formatter decide.
1356
1445
:param show_advice: whether to show advice at the end of the
1447
:param author_list_handler: callable generating a list of
1448
authors to display for a given revision
1359
1450
self.to_file = to_file
1360
1451
# '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
1452
# and should not try to decode/encode it to unicode to avoid bug
1362
1454
if to_exact_file is not None:
1363
1455
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
1457
# XXX: somewhat hacky; this assumes it's a codec writer; it's
1458
# better for code that expects to get diffs to pass in the exact
1368
1460
self.to_exact_file = getattr(to_file, 'stream', to_file)
1369
1461
self.show_ids = show_ids
1370
1462
self.show_timezone = show_timezone
1371
1463
if delta_format is None:
1372
1464
# Ensures backward compatibility
1373
delta_format = 2 # long format
1465
delta_format = 2 # long format
1374
1466
self.delta_format = delta_format
1375
1467
self.levels = levels
1376
1468
self._show_advice = show_advice
1377
1469
self._merge_count = 0
1470
self._author_list_handler = author_list_handler
1379
1472
def get_levels(self):
1380
1473
"""Get the number of levels to display or 0 for all."""
1414
1507
def short_author(self, rev):
1415
name, address = config.parse_username(rev.get_apparent_authors()[0])
1508
return self.authors(rev, 'first', short=True, sep=', ')
1510
def authors(self, rev, who, short=False, sep=None):
1511
"""Generate list of authors, taking --authors option into account.
1513
The caller has to specify the name of a author list handler,
1514
as provided by the author list registry, using the ``who``
1515
argument. That name only sets a default, though: when the
1516
user selected a different author list generation using the
1517
``--authors`` command line switch, as represented by the
1518
``author_list_handler`` constructor argument, that value takes
1521
:param rev: The revision for which to generate the list of authors.
1522
:param who: Name of the default handler.
1523
:param short: Whether to shorten names to either name or address.
1524
:param sep: What separator to use for automatic concatenation.
1526
if self._author_list_handler is not None:
1527
# The user did specify --authors, which overrides the default
1528
author_list_handler = self._author_list_handler
1530
# The user didn't specify --authors, so we use the caller's default
1531
author_list_handler = author_list_registry.get(who)
1532
names = author_list_handler(rev)
1534
for i in range(len(names)):
1535
name, address = config.parse_username(names[i])
1541
names = sep.join(names)
1420
1544
def merge_marker(self, revision):
1421
1545
"""Get the merge marker to include in the output or '' if none."""
1513
1643
lines = [_LONG_SEP]
1514
1644
if revision.revno is not None:
1515
1645
lines.append('revno: %s%s' % (revision.revno,
1516
self.merge_marker(revision)))
1646
self.merge_marker(revision)))
1517
1647
if revision.tags:
1518
lines.append('tags: %s' % (', '.join(revision.tags)))
1648
lines.append('tags: %s' % (', '.join(sorted(revision.tags))))
1649
if self.show_ids or revision.revno is None:
1650
lines.append('revision-id: %s' %
1651
(revision.rev.revision_id.decode('utf-8'),))
1519
1652
if self.show_ids:
1520
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1521
1653
for parent_id in revision.rev.parent_ids:
1522
lines.append('parent: %s' % (parent_id,))
1654
lines.append('parent: %s' % (parent_id.decode('utf-8'),))
1523
1655
lines.extend(self.custom_properties(revision.rev))
1525
1657
committer = revision.rev.committer
1526
authors = revision.rev.get_apparent_authors()
1658
authors = self.authors(revision.rev, 'all')
1527
1659
if authors != [committer]:
1528
1660
lines.append('author: %s' % (", ".join(authors),))
1529
1661
lines.append('committer: %s' % (committer,))
1598
1733
to_file = self.to_file
1600
1735
if revision.tags:
1601
tags = ' {%s}' % (', '.join(revision.tags))
1736
tags = ' {%s}' % (', '.join(sorted(revision.tags)))
1602
1737
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)
1738
revision.revno or "", self.short_author(
1740
format_date(revision.rev.timestamp,
1741
revision.rev.timezone or 0,
1742
self.show_timezone, date_fmt="%Y-%m-%d",
1744
tags, self.merge_marker(revision)))
1745
self.show_properties(revision.rev, indent + offset)
1746
if self.show_ids or revision.revno is None:
1611
1747
to_file.write(indent + offset + 'revision-id:%s\n'
1612
% (revision.rev.revision_id,))
1748
% (revision.rev.revision_id.decode('utf-8'),))
1613
1749
if not revision.rev.message:
1614
1750
to_file.write(indent + offset + '(no message)\n')
1661
1797
def log_revision(self, revision):
1662
1798
indent = ' ' * revision.merge_depth
1663
1799
self.to_file.write(self.log_string(revision.revno, revision.rev,
1664
self._max_chars, revision.tags, indent))
1800
self._max_chars, revision.tags, indent))
1665
1801
self.to_file.write('\n')
1667
1803
def log_string(self, revno, rev, max_chars, tags=None, prefix=''):
1668
1804
"""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
1806
:param revno: revision number or None.
1807
Revision numbers counts from 1.
1808
:param rev: revision object
1809
:param max_chars: maximum length of resulting string
1810
:param tags: list of tags or None
1811
:param prefix: string to prefix each line
1812
:return: formatted truncated string
1679
1816
# show revno only when is not None
1680
1817
out.append("%s:" % revno)
1681
out.append(self.truncate(self.short_author(rev), 20))
1818
if max_chars is not None:
1819
out.append(self.truncate(
1820
self.short_author(rev), (max_chars + 3) // 4))
1822
out.append(self.short_author(rev))
1682
1823
out.append(self.date_string(rev))
1683
1824
if len(rev.parent_ids) > 1:
1684
1825
out.append('[merge]')
1686
tag_str = '{%s}' % (', '.join(tags))
1827
tag_str = '{%s}' % (', '.join(sorted(tags)))
1687
1828
out.append(tag_str)
1688
1829
out.append(rev.get_summary())
1689
1830
return self.truncate(prefix + " ".join(out).rstrip('\n'), max_chars)
1772
1917
return log_formatter_registry.make_formatter(name, *args, **kwargs)
1773
1918
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)
1919
raise errors.CommandError(
1920
gettext("unknown log formatter: %r") % name)
1923
def author_list_all(rev):
1924
return rev.get_apparent_authors()[:]
1927
def author_list_first(rev):
1928
lst = rev.get_apparent_authors()
1935
def author_list_committer(rev):
1936
return [rev.committer]
1939
author_list_registry = registry.Registry()
1941
author_list_registry.register('all', author_list_all,
1944
author_list_registry.register('first', author_list_first,
1947
author_list_registry.register('committer', author_list_committer,
1783
1951
def show_changed_revisions(branch, old_rh, new_rh, to_file=None,
1800
1968
# This is the first index which is different between
1802
1970
base_idx = None
1803
for i in xrange(max(len(new_rh),
1971
for i in range(max(len(new_rh), len(old_rh))):
1805
1972
if (len(new_rh) <= i
1806
1973
or len(old_rh) <= i
1807
or new_rh[i] != old_rh[i]):
1974
or new_rh[i] != old_rh[i]):
1811
1978
if base_idx is None:
1812
1979
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
1981
# TODO: It might be nice to do something like show_log
1982
# and show the merged entries. But since this is the
1983
# removed revisions, it shouldn't be as important
1817
1984
if base_idx < len(old_rh):
1818
to_file.write('*'*60)
1985
to_file.write('*' * 60)
1819
1986
to_file.write('\nRemoved Revisions:\n')
1820
1987
for i in range(base_idx, len(old_rh)):
1821
1988
rev = branch.repository.get_revision(old_rh[i])
1822
lr = LogRevision(rev, i+1, 0, None)
1989
lr = LogRevision(rev, i + 1, 0, None)
1823
1990
lf.log_revision(lr)
1824
to_file.write('*'*60)
1991
to_file.write('*' * 60)
1825
1992
to_file.write('\n\n')
1826
1993
if base_idx < len(new_rh):
1827
1994
to_file.write('Added Revisions:\n')
1828
1995
show_log(branch,
1832
1998
direction='forward',
1833
start_revision=base_idx+1,
1834
end_revision=len(new_rh),
1999
start_revision=base_idx + 1,
2000
end_revision=len(new_rh))
1838
2003
def get_history_change(old_revision_id, new_revision_id, repository):
1940
2105
:param file_list: the list of paths given on the command line;
1941
2106
the first of these can be a branch location or a file path,
1942
2107
the remainder must be file paths
1943
:param add_cleanup: When the branch returned is read locked,
1944
an unlock call will be queued to the cleanup.
2108
:param exit_stack: When the branch returned is read locked,
2109
an unlock call will be queued to the exit stack.
1945
2110
:return: (branch, info_list, start_rev_info, end_rev_info) where
1946
info_list is a list of (relative_path, file_id, kind) tuples where
2111
info_list is a list of (relative_path, found, kind) tuples where
1947
2112
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1948
2113
branch will be read-locked.
1950
from builtins import _get_revision_range, safe_relpath_files
1951
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
1952
add_cleanup(b.lock_read().unlock)
2115
from breezy.builtins import _get_revision_range
2116
tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
2118
exit_stack.enter_context(b.lock_read())
1953
2119
# XXX: It's damn messy converting a list of paths to relative paths when
1954
2120
# those paths might be deleted ones, they might be on a case-insensitive
1955
2121
# filesystem and/or they might be in silly locations (like another branch).
1972
2138
tree = b.basis_tree()
1974
2140
for fp in relpaths:
1975
file_id = tree.path2id(fp)
1976
kind = _get_kind_for_file_id(tree, file_id)
2141
kind = _get_kind_for_file(tree, fp)
1978
2143
# go back to when time began
1979
2144
if tree1 is None:
1981
2146
rev1 = b.get_rev_id(1)
1982
2147
except errors.NoSuchRevision:
1983
2148
# No history at all
1987
2151
tree1 = b.repository.revision_tree(rev1)
1989
file_id = tree1.path2id(fp)
1990
kind = _get_kind_for_file_id(tree1, file_id)
1991
info_list.append((fp, file_id, kind))
2153
kind = _get_kind_for_file(tree1, fp)
2154
info_list.append((fp, kind))
1993
2156
elif start_rev_info == end_rev_info:
1994
2157
# One revision given - file must exist in it
1995
2158
tree = b.repository.revision_tree(end_rev_info.rev_id)
1996
2159
for fp in relpaths:
1997
file_id = tree.path2id(fp)
1998
kind = _get_kind_for_file_id(tree, file_id)
1999
info_list.append((fp, file_id, kind))
2160
kind = _get_kind_for_file(tree, fp)
2161
info_list.append((fp, kind))
2002
2164
# Revision range given. Get the file-id from the end tree.
2018
2179
tree1 = b.repository.revision_tree(rev1)
2020
2181
tree1 = b.repository.revision_tree(rev_id)
2021
file_id = tree1.path2id(fp)
2022
kind = _get_kind_for_file_id(tree1, file_id)
2023
info_list.append((fp, file_id, kind))
2182
kind = _get_kind_for_file(tree1, fp)
2183
info_list.append((fp, kind))
2024
2184
return b, info_list, start_rev_info, end_rev_info
2027
def _get_kind_for_file_id(tree, file_id):
2028
"""Return the kind of a file-id or None if it doesn't exist."""
2029
if file_id is not None:
2030
return tree.kind(file_id)
2187
def _get_kind_for_file(tree, path):
2188
"""Return the kind of a path or None if it doesn't exist."""
2189
with tree.lock_read():
2191
return tree.stored_kind(path)
2192
except errors.NoSuchFile:
2035
2196
properties_handler_registry = registry.Registry()
2037
2198
# Use the properties handlers to print out bug information if available
2038
2201
def _bugs_properties_handler(revision):
2039
if revision.properties.has_key('bugs'):
2040
bug_lines = revision.properties['bugs'].split('\n')
2041
bug_rows = [line.split(' ', 1) for line in bug_lines]
2042
fixed_bug_urls = [row[0] for row in bug_rows if
2043
len(row) > 1 and row[1] == 'fixed']
2203
related_bug_urls = []
2204
for bug_url, status in revision.iter_bugs():
2205
if status == 'fixed':
2206
fixed_bug_urls.append(bug_url)
2207
elif status == 'related':
2208
related_bug_urls.append(bug_url)
2211
text = ngettext('fixes bug', 'fixes bugs', len(fixed_bug_urls))
2212
ret[text] = ' '.join(fixed_bug_urls)
2213
if related_bug_urls:
2214
text = ngettext('related bug', 'related bugs',
2215
len(related_bug_urls))
2216
ret[text] = ' '.join(related_bug_urls)
2046
return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2049
2220
properties_handler_registry.register('bugs_properties_handler',
2050
2221
_bugs_properties_handler)
added
removed
breezy/log.py
