184
167
:param limit: If set, shows only 'limit' revisions, all revisions are shown
187
:param show_diff: If True, output a diff after each 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'
203
diff_type = 'partial'
209
# Build the request and execute it
210
rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
211
start_revision=start_revision, end_revision=end_revision,
212
limit=limit, message_search=search,
213
delta_type=delta_type, diff_type=diff_type)
214
Logger(branch, rqst).show(lf)
217
# Note: This needs to be kept this in sync with the defaults in
218
# make_log_request_dict() below
219
_DEFAULT_REQUEST_PARAMS = {
220
'direction': 'reverse',
222
'generate_tags': True,
223
'exclude_common_ancestry': False,
224
'_match_using_deltas': True,
228
def make_log_request_dict(direction='reverse', specific_fileids=None,
229
start_revision=None, end_revision=None, limit=None,
230
message_search=None, levels=1, generate_tags=True,
232
diff_type=None, _match_using_deltas=True,
233
exclude_common_ancestry=False,
235
"""Convenience function for making a logging request dictionary.
237
Using this function may make code slightly safer by ensuring
238
parameters have the correct names. It also provides a reference
239
point for documenting the supported parameters.
241
:param direction: 'reverse' (default) is latest to earliest;
242
'forward' is earliest to latest.
244
:param specific_fileids: If not None, only include revisions
245
affecting the specified files, rather than all revisions.
247
:param start_revision: If not None, only generate
248
revisions >= start_revision
250
:param end_revision: If not None, only generate
251
revisions <= end_revision
253
:param limit: If set, generate only 'limit' revisions, all revisions
254
are shown if None or 0.
256
:param message_search: If not None, only include revisions with
257
matching commit messages
259
:param levels: the number of levels of revisions to
260
generate; 1 for just the mainline; 0 for all levels.
262
:param generate_tags: If True, include tags for matched revisions.
264
:param delta_type: Either 'full', 'partial' or None.
265
'full' means generate the complete delta - adds/deletes/modifies/etc;
266
'partial' means filter the delta using specific_fileids;
267
None means do not generate any delta.
269
:param diff_type: Either 'full', 'partial' or None.
270
'full' means generate the complete diff - adds/deletes/modifies/etc;
271
'partial' means filter the diff using specific_fileids;
272
None means do not generate any diff.
274
: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
279
:param exclude_common_ancestry: Whether -rX..Y should be interpreted as a
280
range operator or as a graph difference.
283
'direction': direction,
284
'specific_fileids': specific_fileids,
285
'start_revision': start_revision,
286
'end_revision': end_revision,
288
'message_search': message_search,
290
'generate_tags': generate_tags,
291
'delta_type': delta_type,
292
'diff_type': diff_type,
293
'exclude_common_ancestry': exclude_common_ancestry,
294
# Add 'private' attributes for features that may be deprecated
295
'_match_using_deltas': _match_using_deltas,
299
def _apply_log_request_defaults(rqst):
300
"""Apply default values to a request dictionary."""
301
result = _DEFAULT_REQUEST_PARAMS
307
class LogGenerator(object):
308
"""A generator of log revisions."""
310
def iter_log_revisions(self):
311
"""Iterate over LogRevision objects.
313
:return: An iterator yielding LogRevision objects.
315
raise NotImplementedError(self.iter_log_revisions)
318
class Logger(object):
319
"""An object that generates, formats and displays a log."""
321
def __init__(self, branch, rqst):
324
:param branch: the branch to log
325
:param rqst: A dictionary specifying the query parameters.
326
See make_log_request_dict() for supported values.
329
self.rqst = _apply_log_request_defaults(rqst)
334
:param lf: The LogFormatter object to send the output to.
336
if not isinstance(lf, LogFormatter):
337
warn("not a LogFormatter instance: %r" % lf)
339
self.branch.lock_read()
341
if getattr(lf, 'begin_log', None):
344
if getattr(lf, 'end_log', None):
349
def _show_body(self, lf):
350
"""Show the main log output.
352
Subclasses may wish to override this.
354
# Tweak the LogRequest based on what the LogFormatter can handle.
355
# (There's no point generating stuff if the formatter can't display it.)
357
rqst['levels'] = lf.get_levels()
358
if not getattr(lf, 'supports_tags', False):
359
rqst['generate_tags'] = False
360
if not getattr(lf, 'supports_delta', False):
361
rqst['delta_type'] = None
362
if not getattr(lf, 'supports_diff', False):
363
rqst['diff_type'] = None
365
# Find and print the interesting revisions
366
generator = self._generator_factory(self.branch, rqst)
367
for lr in generator.iter_log_revisions():
172
if getattr(lf, 'begin_log', None):
175
_show_log(branch, lf, specific_fileid, verbose, direction,
176
start_revision, end_revision, search, limit)
178
if getattr(lf, 'end_log', None):
184
def _show_log(branch,
186
specific_fileid=None,
193
"""Worker function for show_log - see show_log."""
194
if not isinstance(lf, LogFormatter):
195
warn("not a LogFormatter instance: %r" % lf)
198
trace.mutter('get log for file_id %r', specific_fileid)
199
generate_merge_revisions = getattr(lf, 'supports_merge_revisions', False)
200
allow_single_merge_revision = getattr(lf,
201
'supports_single_merge_revision', False)
202
view_revisions = calculate_view_revisions(branch, start_revision,
203
end_revision, direction,
205
generate_merge_revisions,
206
allow_single_merge_revision)
208
generate_tags = getattr(lf, 'supports_tags', False)
210
if branch.supports_tags():
211
rev_tag_dict = branch.tags.get_reverse_tag_dict()
213
generate_delta = verbose and getattr(lf, 'supports_delta', False)
215
# now we just print all the revisions
217
revision_iterator = make_log_rev_iterator(branch, view_revisions,
218
generate_delta, search)
219
for revs in revision_iterator:
220
for (rev_id, revno, merge_depth), rev, delta in revs:
221
lr = LogRevision(rev, revno, merge_depth, delta,
222
rev_tag_dict.get(rev_id))
368
223
lf.log_revision(lr)
371
def _generator_factory(self, branch, rqst):
372
"""Make the LogGenerator object to use.
374
Subclasses may wish to override this.
376
return _DefaultLogGenerator(branch, rqst)
379
class _StartNotLinearAncestor(Exception):
380
"""Raised when a start revision is not found walking left-hand history."""
383
class _DefaultLogGenerator(LogGenerator):
384
"""The default generator of log revisions."""
386
def __init__(self, branch, rqst):
389
if rqst.get('generate_tags') and branch.supports_tags():
390
self.rev_tag_dict = branch.tags.get_reverse_tag_dict()
392
self.rev_tag_dict = {}
394
def iter_log_revisions(self):
395
"""Iterate over LogRevision objects.
397
:return: An iterator yielding LogRevision objects.
400
levels = rqst.get('levels')
401
limit = rqst.get('limit')
402
diff_type = rqst.get('diff_type')
404
revision_iterator = self._create_log_revision_iterator()
405
for revs in revision_iterator:
406
for (rev_id, revno, merge_depth), rev, delta in revs:
407
# 0 levels means show everything; merge_depth counts from 0
408
if levels != 0 and merge_depth >= levels:
410
if 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)
418
if log_count >= 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
def _create_log_revision_iterator(self):
440
"""Create a revision iterator for log.
442
: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()
451
# We're using the per-file-graph algorithm. This scales really
452
# well but only makes sense if there is a single file and it's
454
file_count = len(self.rqst.get('specific_fileids'))
456
raise BzrError("illegal LogRequest: must match-using-deltas "
457
"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'))
497
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
498
generate_merge_revisions,
499
delayed_graph_generation=False,
500
exclude_common_ancestry=False,
502
"""Calculate the revisions to view.
504
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
505
a list of the same tuples.
507
if (exclude_common_ancestry and start_rev_id == end_rev_id):
508
raise errors.BzrCommandError(
509
'--exclude-common-ancestry requires two different revisions')
510
if direction not in ('reverse', 'forward'):
511
raise ValueError('invalid direction %r' % direction)
512
br_revno, br_rev_id = branch.last_revision_info()
226
if log_count >= limit:
230
def calculate_view_revisions(branch, start_revision, end_revision, direction,
231
specific_fileid, generate_merge_revisions,
232
allow_single_merge_revision):
233
if ( not generate_merge_revisions
234
and start_revision is end_revision is None
235
and direction == 'reverse'
236
and specific_fileid is None):
237
return _linear_view_revisions(branch)
239
mainline_revs, rev_nos, start_rev_id, end_rev_id = _get_mainline_revs(
240
branch, start_revision, end_revision)
241
if not mainline_revs:
516
if (end_rev_id and start_rev_id == end_rev_id
517
and (not generate_merge_revisions
518
or not _has_merges(branch, end_rev_id))):
519
# 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)))
537
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):
538
if rev_id == br_rev_id:
540
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)
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.')
561
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
562
delayed_graph_generation,
563
exclude_common_ancestry=False):
564
# On large trees, generating the merge graph can take 30-60 seconds
565
# so we delay doing it until a merge is detected, incrementally
566
# returning initial (non-merge) revisions while we can.
568
# The above is only true for old formats (<= 0.92), for newer formats, a
569
# couple of seconds only should be needed to load the whole graph and the
570
# other graph operations needed are even faster than that -- vila 100201
571
initial_revisions = []
572
if delayed_graph_generation:
574
for rev_id, revno, depth in _linear_view_revisions(
575
branch, start_rev_id, end_rev_id):
576
if _has_merges(branch, rev_id):
577
# The end_rev_id can be nested down somewhere. We need an
578
# explicit ancestry check. There is an ambiguity here as we
579
# may not raise _StartNotLinearAncestor for a revision that
580
# is an ancestor but not a *linear* one. But since we have
581
# loaded the graph to do the check (or calculate a dotted
582
# revno), we may as well accept to show the log... We need
583
# the check only if start_rev_id is not None as all
584
# revisions have _mod_revision.NULL_REVISION as an ancestor
586
graph = branch.repository.get_graph()
587
if (start_rev_id is not None
588
and not graph.is_ancestor(start_rev_id, end_rev_id)):
589
raise _StartNotLinearAncestor()
590
# Since we collected the revisions so far, we need to
595
initial_revisions.append((rev_id, revno, depth))
597
# No merged revisions found
598
return initial_revisions
599
except _StartNotLinearAncestor:
600
# A merge was never detected so the lower revision limit can't
601
# be nested down somewhere
602
raise errors.BzrCommandError('Start revision not found in'
603
' history of end revision.')
605
# We exit the loop above because we encounter a revision with merges, from
606
# this revision, we need to switch to _graph_view_revisions.
608
# A log including nested merges is required. If the direction is reverse,
609
# we rebase the initial merge depths so that the development line is
610
# shown naturally, i.e. just like it is for linear logging. We can easily
611
# make forward the exact opposite display, but showing the merge revisions
612
# indented at the end seems slightly nicer in that case.
613
view_revisions = chain(iter(initial_revisions),
614
_graph_view_revisions(branch, start_rev_id, end_rev_id,
615
rebase_initial_depths=(direction == 'reverse'),
616
exclude_common_ancestry=exclude_common_ancestry))
617
return view_revisions
620
def _has_merges(branch, rev_id):
621
"""Does a revision have multiple parents or not?"""
622
parents = branch.repository.get_parent_map([rev_id]).get(rev_id, [])
623
return len(parents) > 1
626
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
627
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
628
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)
631
if len(start_dotted) == 1 and len(end_dotted) == 1:
633
return start_dotted[0] <= end_dotted[0]
634
elif (len(start_dotted) == 3 and len(end_dotted) == 3 and
635
start_dotted[0:1] == end_dotted[0:1]):
636
# both on same development line
637
return start_dotted[2] <= end_dotted[2]
641
# if either start or end is not specified then we use either the first or
642
# the last revision and *they* are obvious ancestors.
646
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
647
"""Calculate a sequence of revisions to view, newest to oldest.
649
:param start_rev_id: the lower revision-id
650
:param end_rev_id: the upper revision-id
651
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
652
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
653
is not found walking the left-hand history
655
br_revno, br_rev_id = branch.last_revision_info()
656
repo = branch.repository
657
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
663
if end_rev_id is None:
664
end_rev_id = br_rev_id
665
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
674
yield revision_id, revno_str, 0
677
raise _StartNotLinearAncestor()
680
def _graph_view_revisions(branch, start_rev_id, end_rev_id,
681
rebase_initial_depths=True,
682
exclude_common_ancestry=False):
683
"""Calculate revisions to view including merges, newest to oldest.
685
:param branch: the branch
686
:param start_rev_id: the lower revision-id
687
:param end_rev_id: the upper revision-id
688
:param rebase_initial_depth: should depths be rebased until a mainline
690
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
692
if exclude_common_ancestry:
693
stop_rule = 'with-merges-without-common-ancestry'
695
stop_rule = 'with-merges'
696
view_revisions = branch.iter_merge_sorted_revisions(
697
start_revision_id=end_rev_id, stop_revision_id=start_rev_id,
699
if not rebase_initial_depths:
700
for (rev_id, merge_depth, revno, end_of_merge
702
yield rev_id, '.'.join(map(str, revno)), merge_depth
704
# We're following a development line starting at a merged revision.
705
# We need to adjust depths down by the initial depth until we find
706
# a depth less than it. Then we use that depth as the adjustment.
707
# If and when we reach the mainline, depth adjustment ends.
708
depth_adjustment = None
709
for (rev_id, merge_depth, revno, end_of_merge
711
if depth_adjustment is None:
712
depth_adjustment = merge_depth
714
if merge_depth < depth_adjustment:
715
# From now on we reduce the depth adjustement, this can be
716
# surprising for users. The alternative requires two passes
717
# which breaks the fast display of the first revision
719
depth_adjustment = merge_depth
720
merge_depth -= depth_adjustment
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))
244
generate_single_revision = False
245
if ((not generate_merge_revisions)
246
and ((start_rev_id and (start_rev_id not in rev_nos))
247
or (end_rev_id and (end_rev_id not in rev_nos)))):
248
generate_single_revision = ((start_rev_id == end_rev_id)
249
and allow_single_merge_revision)
250
if not generate_single_revision:
251
raise errors.BzrCommandError('Selected log formatter only supports'
252
' mainline revisions.')
253
generate_merge_revisions = generate_single_revision
254
view_revs_iter = get_view_revisions(mainline_revs, rev_nos, branch,
255
direction, include_merges=generate_merge_revisions)
257
if direction == 'reverse':
258
start_rev_id, end_rev_id = end_rev_id, start_rev_id
259
view_revisions = _filter_revision_range(list(view_revs_iter),
262
if view_revisions and generate_single_revision:
263
view_revisions = view_revisions[0:1]
736
264
if specific_fileid:
737
265
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
def _rebase_merge_depth(view_revisions):
744
"""Adjust depths upwards so the top level is 0."""
745
# If either the first or last revision have a merge_depth of 0, we're done
269
# rebase merge_depth - unless there are no revisions or
270
# either the first or last revision have merge_depth = 0.
746
271
if view_revisions and view_revisions[0][2] and view_revisions[-1][2]:
747
272
min_depth = min([d for r,n,d in view_revisions])
748
273
if min_depth != 0:
1414
760
def short_author(self, rev):
1415
name, address = config.parse_username(rev.get_apparent_authors()[0])
761
name, address = config.parse_username(rev.get_apparent_author())
1420
def merge_marker(self, revision):
1421
"""Get the merge marker to include in the output or '' if none."""
1422
if len(revision.rev.parent_ids) > 1:
1423
self._merge_count += 1
1428
766
def show_properties(self, revision, indent):
1429
767
"""Displays the custom properties returned by each registered handler.
1431
If a registered handler raises an error it is propagated.
1433
for line in self.custom_properties(revision):
1434
self.to_file.write("%s%s\n" % (indent, line))
1436
def custom_properties(self, revision):
1437
"""Format the custom properties returned by each registered handler.
1439
If a registered handler raises an error it is propagated.
1441
:return: a list of formatted lines (excluding trailing newlines)
1443
lines = self._foreign_info_properties(revision)
769
If a registered handler raises an error it is propagated.
1444
771
for key, handler in properties_handler_registry.iteritems():
1445
lines.extend(self._format_properties(handler(revision)))
1448
def _foreign_info_properties(self, rev):
1449
"""Custom log displayer for foreign revision identifiers.
1451
:param rev: Revision object.
1453
# Revision comes directly from a foreign repository
1454
if isinstance(rev, foreign.ForeignRevision):
1455
return self._format_properties(
1456
rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
1458
# Imported foreign revision revision ids always contain :
1459
if not ":" in rev.revision_id:
1462
# Revision was once imported from a foreign repository
1464
foreign_revid, mapping = \
1465
foreign.foreign_vcs_registry.parse_revision_id(rev.revision_id)
1466
except errors.InvalidRevisionId:
1469
return self._format_properties(
1470
mapping.vcs.show_foreign_revid(foreign_revid))
1472
def _format_properties(self, properties):
1474
for key, value in properties.items():
1475
lines.append(key + ': ' + value)
1478
def show_diff(self, to_file, diff, indent):
1479
for l in diff.rstrip().split('\n'):
1480
to_file.write(indent + '%s\n' % (l,))
1483
# Separator between revisions in long format
1484
_LONG_SEP = '-' * 60
772
for key, value in handler(revision).items():
773
self.to_file.write(indent + key + ': ' + value + '\n')
1487
776
class LongLogFormatter(LogFormatter):
1489
778
supports_merge_revisions = True
1490
preferred_levels = 1
1491
779
supports_delta = True
1492
780
supports_tags = True
1493
supports_diff = True
1495
def __init__(self, *args, **kwargs):
1496
super(LongLogFormatter, self).__init__(*args, **kwargs)
1497
if self.show_timezone == 'original':
1498
self.date_string = self._date_string_original_timezone
1500
self.date_string = self._date_string_with_timezone
1502
def _date_string_with_timezone(self, rev):
1503
return format_date(rev.timestamp, rev.timezone or 0,
1506
def _date_string_original_timezone(self, rev):
1507
return format_date_with_offset_in_original_timezone(rev.timestamp,
1510
782
def log_revision(self, revision):
1511
783
"""Log a revision, either merged or not."""
1512
784
indent = ' ' * revision.merge_depth
785
to_file = self.to_file
786
to_file.write(indent + '-' * 60 + '\n')
1514
787
if revision.revno is not None:
1515
lines.append('revno: %s%s' % (revision.revno,
1516
self.merge_marker(revision)))
788
to_file.write(indent + 'revno: %s\n' % (revision.revno,))
1517
789
if revision.tags:
1518
lines.append('tags: %s' % (', '.join(revision.tags)))
790
to_file.write(indent + 'tags: %s\n' % (', '.join(revision.tags)))
1519
791
if self.show_ids:
1520
lines.append('revision-id: %s' % (revision.rev.revision_id,))
792
to_file.write(indent + 'revision-id: ' + revision.rev.revision_id)
1521
794
for parent_id in revision.rev.parent_ids:
1522
lines.append('parent: %s' % (parent_id,))
1523
lines.extend(self.custom_properties(revision.rev))
795
to_file.write(indent + 'parent: %s\n' % (parent_id,))
796
self.show_properties(revision.rev, indent)
1525
committer = revision.rev.committer
1526
authors = revision.rev.get_apparent_authors()
1527
if authors != [committer]:
1528
lines.append('author: %s' % (", ".join(authors),))
1529
lines.append('committer: %s' % (committer,))
798
author = revision.rev.properties.get('author', None)
799
if author is not None:
800
to_file.write(indent + 'author: %s\n' % (author,))
801
to_file.write(indent + 'committer: %s\n' % (revision.rev.committer,))
1531
803
branch_nick = revision.rev.properties.get('branch-nick', None)
1532
804
if branch_nick is not None:
1533
lines.append('branch nick: %s' % (branch_nick,))
1535
lines.append('timestamp: %s' % (self.date_string(revision.rev),))
1537
lines.append('message:')
805
to_file.write(indent + 'branch nick: %s\n' % (branch_nick,))
807
date_str = format_date(revision.rev.timestamp,
808
revision.rev.timezone or 0,
810
to_file.write(indent + 'timestamp: %s\n' % (date_str,))
812
to_file.write(indent + 'message:\n')
1538
813
if not revision.rev.message:
1539
lines.append(' (no message)')
814
to_file.write(indent + ' (no message)\n')
1541
816
message = revision.rev.message.rstrip('\r\n')
1542
817
for l in message.split('\n'):
1543
lines.append(' %s' % (l,))
1545
# Dump the output, appending the delta and diff if requested
1546
to_file = self.to_file
1547
to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
818
to_file.write(indent + ' %s\n' % (l,))
1548
819
if revision.delta is not None:
1549
# Use the standard status output to display changes
1550
from bzrlib.delta import report_delta
1551
report_delta(to_file, revision.delta, short_status=False,
1552
show_ids=self.show_ids, indent=indent)
1553
if revision.diff is not None:
1554
to_file.write(indent + 'diff:\n')
1556
# Note: we explicitly don't indent the diff (relative to the
1557
# revision information) so that the output can be fed to patch -p0
1558
self.show_diff(self.to_exact_file, revision.diff, indent)
1559
self.to_exact_file.flush()
1561
def get_advice_separator(self):
1562
"""Get the text separating the log from the closing advice."""
1563
return '-' * 60 + '\n'
820
# We don't respect delta_format for compatibility
821
revision.delta.show(to_file, self.show_ids, indent=indent,
1566
825
class ShortLogFormatter(LogFormatter):
1568
supports_merge_revisions = True
1569
preferred_levels = 1
1570
827
supports_delta = True
1571
supports_tags = True
1572
supports_diff = True
1574
def __init__(self, *args, **kwargs):
1575
super(ShortLogFormatter, self).__init__(*args, **kwargs)
1576
self.revno_width_by_depth = {}
828
supports_single_merge_revision = True
1578
830
def log_revision(self, revision):
1579
# We need two indents: one per depth and one for the information
1580
# relative to that indent. Most mainline revnos are 5 chars or
1581
# less while dotted revnos are typically 11 chars or less. Once
1582
# calculated, we need to remember the offset for a given depth
1583
# as we might be starting from a dotted revno in the first column
1584
# and we want subsequent mainline revisions to line up.
1585
depth = revision.merge_depth
1586
indent = ' ' * depth
1587
revno_width = self.revno_width_by_depth.get(depth)
1588
if revno_width is None:
1589
if revision.revno.find('.') == -1:
1590
# mainline revno, e.g. 12345
1593
# dotted revno, e.g. 12345.10.55
1595
self.revno_width_by_depth[depth] = revno_width
1596
offset = ' ' * (revno_width + 1)
1598
831
to_file = self.to_file
1601
tags = ' {%s}' % (', '.join(revision.tags))
1602
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1603
revision.revno, self.short_author(revision.rev),
833
if len(revision.rev.parent_ids) > 1:
834
is_merge = ' [merge]'
835
to_file.write("%5s %s\t%s%s\n" % (revision.revno,
836
self.short_author(revision.rev),
1604
837
format_date(revision.rev.timestamp,
1605
838
revision.rev.timezone or 0,
1606
839
self.show_timezone, date_fmt="%Y-%m-%d",
1607
840
show_offset=False),
1608
tags, self.merge_marker(revision)))
1609
self.show_properties(revision.rev, indent+offset)
1610
842
if self.show_ids:
1611
to_file.write(indent + offset + 'revision-id:%s\n'
843
to_file.write(' revision-id:%s\n'
1612
844
% (revision.rev.revision_id,))
1613
845
if not revision.rev.message:
1614
to_file.write(indent + offset + '(no message)\n')
846
to_file.write(' (no message)\n')
1616
848
message = revision.rev.message.rstrip('\r\n')
1617
849
for l in message.split('\n'):
1618
to_file.write(indent + offset + '%s\n' % (l,))
850
to_file.write(' %s\n' % (l,))
1620
852
if revision.delta is not None:
1621
# Use the standard status output to display changes
1622
from bzrlib.delta import report_delta
1623
report_delta(to_file, revision.delta,
1624
short_status=self.delta_format==1,
1625
show_ids=self.show_ids, indent=indent + offset)
1626
if revision.diff is not None:
1627
self.show_diff(self.to_exact_file, revision.diff, ' ')
853
revision.delta.show(to_file, self.show_ids,
854
short_status=self.delta_format==1)
1628
855
to_file.write('\n')
1631
858
class LineLogFormatter(LogFormatter):
1633
supports_merge_revisions = True
1634
preferred_levels = 1
1635
supports_tags = True
860
supports_single_merge_revision = True
1637
862
def __init__(self, *args, **kwargs):
1638
863
super(LineLogFormatter, self).__init__(*args, **kwargs)
1639
width = terminal_width()
1640
if width is not None:
1641
# we need one extra space for terminals that wrap on last char
1643
self._max_chars = width
864
self._max_chars = terminal_width() - 1
1645
866
def truncate(self, str, max_len):
1646
if max_len is None or len(str) <= max_len:
867
if len(str) <= max_len:
1648
return str[:max_len-3] + '...'
869
return str[:max_len-3]+'...'
1650
871
def date_string(self, rev):
1651
872
return format_date(rev.timestamp, rev.timezone or 0,