219
215
'direction': 'reverse',
221
217
'generate_tags': True,
222
'exclude_common_ancestry': False,
223
218
'_match_using_deltas': True,
227
222
def make_log_request_dict(direction='reverse', specific_fileids=None,
228
start_revision=None, end_revision=None, limit=None,
229
message_search=None, levels=1, generate_tags=True,
231
diff_type=None, _match_using_deltas=True,
232
exclude_common_ancestry=False,
223
start_revision=None, end_revision=None, limit=None,
224
message_search=None, levels=1, generate_tags=True, delta_type=None,
225
diff_type=None, _match_using_deltas=True):
234
226
"""Convenience function for making a logging request dictionary.
236
228
Using this function may make code slightly safer by ensuring
396
384
:return: An iterator yielding LogRevision objects.
399
levels = rqst.get('levels')
400
limit = rqst.get('limit')
401
diff_type = rqst.get('diff_type')
403
388
revision_iterator = self._create_log_revision_iterator()
404
389
for revs in revision_iterator:
405
390
for (rev_id, revno, merge_depth), rev, delta in revs:
406
391
# 0 levels means show everything; merge_depth counts from 0
392
levels = rqst.get('levels')
407
393
if levels != 0 and merge_depth >= levels:
409
if diff_type is None:
412
diff = self._format_diff(rev, rev_id, diff_type)
395
diff = self._format_diff(rev, rev_id)
413
396
yield LogRevision(rev, revno, merge_depth, delta,
414
397
self.rev_tag_dict.get(rev_id), diff)
398
limit = rqst.get('limit')
417
401
if log_count >= limit:
420
def _format_diff(self, rev, rev_id, diff_type):
404
def _format_diff(self, rev, rev_id):
405
diff_type = self.rqst.get('diff_type')
406
if diff_type is None:
421
408
repo = self.branch.repository
422
409
if len(rev.parent_ids) == 0:
423
410
ancestor_id = _mod_revision.NULL_REVISION
463
449
generate_merge_revisions = rqst.get('levels') != 1
464
450
delayed_graph_generation = not rqst.get('specific_fileids') and (
465
451
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'))
452
view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
453
self.end_rev_id, rqst.get('direction'), generate_merge_revisions,
454
delayed_graph_generation=delayed_graph_generation)
473
456
# Apply the other filters
474
457
return make_log_rev_iterator(self.branch, view_revisions,
481
464
# Note that we always generate the merge revisions because
482
465
# 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'))
467
view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
468
self.end_rev_id, rqst.get('direction'), True)
488
469
if not isinstance(view_revisions, list):
489
470
view_revisions = list(view_revisions)
490
471
view_revisions = _filter_revisions_touching_file_id(self.branch,
497
478
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,
479
generate_merge_revisions, delayed_graph_generation=False):
502
480
"""Calculate the revisions to view.
504
482
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR
505
483
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
485
br_revno, br_rev_id = branch.last_revision_info()
513
486
if br_revno == 0:
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,
525
direction, exclude_common_ancestry)
526
if direction == 'forward':
527
iter_revs = reversed(iter_revs)
489
# If a single revision is requested, check we can handle it
490
generate_single_revision = (end_rev_id and start_rev_id == end_rev_id and
491
(not generate_merge_revisions or not _has_merges(branch, end_rev_id)))
492
if generate_single_revision:
493
return _generate_one_revision(branch, end_rev_id, br_rev_id, br_revno)
495
# If we only want to see linear revisions, we can iterate ...
496
if not generate_merge_revisions:
497
return _generate_flat_revisions(branch, start_rev_id, end_rev_id,
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)))
500
return _generate_all_revisions(branch, start_rev_id, end_rev_id,
501
direction, delayed_graph_generation)
537
504
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):
540
507
return [(br_rev_id, br_revno, 0)]
542
revno_str = _compute_revno_str(branch, rev_id)
509
revno = branch.revision_id_to_dotted_revno(rev_id)
510
revno_str = '.'.join(str(n) for n in revno)
543
511
return [(rev_id, revno_str, 0)]
546
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction,
547
exclude_common_ancestry=False):
548
result = _linear_view_revisions(
549
branch, start_rev_id, end_rev_id,
550
exclude_common_ancestry=exclude_common_ancestry)
514
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction):
515
result = _linear_view_revisions(branch, start_rev_id, end_rev_id)
551
516
# If a start limit was given and it's not obviously an
552
517
# ancestor of the end limit, check it before outputting anything
553
518
if direction == 'forward' or (start_rev_id
557
522
except _StartNotLinearAncestor:
558
523
raise errors.BzrCommandError('Start revision not found in'
559
524
' left-hand history of end revision.')
525
if direction == 'forward':
526
result = reversed(result)
563
530
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
564
delayed_graph_generation,
565
exclude_common_ancestry=False):
531
delayed_graph_generation):
566
532
# On large trees, generating the merge graph can take 30-60 seconds
567
533
# so we delay doing it until a merge is detected, incrementally
568
534
# returning initial (non-merge) revisions while we can.
570
# The above is only true for old formats (<= 0.92), for newer formats, a
571
# couple of seconds only should be needed to load the whole graph and the
572
# other graph operations needed are even faster than that -- vila 100201
573
535
initial_revisions = []
574
536
if delayed_graph_generation:
576
for rev_id, revno, depth in _linear_view_revisions(
577
branch, start_rev_id, end_rev_id, exclude_common_ancestry):
538
for rev_id, revno, depth in \
539
_linear_view_revisions(branch, start_rev_id, end_rev_id):
578
540
if _has_merges(branch, rev_id):
579
# The end_rev_id can be nested down somewhere. We need an
580
# explicit ancestry check. There is an ambiguity here as we
581
# may not raise _StartNotLinearAncestor for a revision that
582
# is an ancestor but not a *linear* one. But since we have
583
# loaded the graph to do the check (or calculate a dotted
584
# revno), we may as well accept to show the log... We need
585
# the check only if start_rev_id is not None as all
586
# revisions have _mod_revision.NULL_REVISION as an ancestor
588
graph = branch.repository.get_graph()
589
if (start_rev_id is not None
590
and not graph.is_ancestor(start_rev_id, end_rev_id)):
591
raise _StartNotLinearAncestor()
592
# Since we collected the revisions so far, we need to
594
541
end_rev_id = rev_id
597
544
initial_revisions.append((rev_id, revno, depth))
599
546
# No merged revisions found
600
return initial_revisions
547
if direction == 'reverse':
548
return initial_revisions
549
elif direction == 'forward':
550
return reversed(initial_revisions)
552
raise ValueError('invalid direction %r' % direction)
601
553
except _StartNotLinearAncestor:
602
554
# A merge was never detected so the lower revision limit can't
603
555
# be nested down somewhere
604
556
raise errors.BzrCommandError('Start revision not found in'
605
557
' history of end revision.')
607
# We exit the loop above because we encounter a revision with merges, from
608
# this revision, we need to switch to _graph_view_revisions.
610
559
# A log including nested merges is required. If the direction is reverse,
611
560
# we rebase the initial merge depths so that the development line is
612
561
# shown naturally, i.e. just like it is for linear logging. We can easily
614
563
# indented at the end seems slightly nicer in that case.
615
564
view_revisions = chain(iter(initial_revisions),
616
565
_graph_view_revisions(branch, start_rev_id, end_rev_id,
617
rebase_initial_depths=(direction == 'reverse'),
618
exclude_common_ancestry=exclude_common_ancestry))
619
return view_revisions
566
rebase_initial_depths=direction == 'reverse'))
567
if direction == 'reverse':
568
return view_revisions
569
elif direction == 'forward':
570
# Forward means oldest first, adjusting for depth.
571
view_revisions = reverse_by_depth(list(view_revisions))
572
return _rebase_merge_depth(view_revisions)
574
raise ValueError('invalid direction %r' % direction)
622
577
def _has_merges(branch, rev_id):
625
580
return len(parents) > 1
628
def _compute_revno_str(branch, rev_id):
629
"""Compute the revno string from a rev_id.
631
:return: The revno string, or None if the revision is not in the supplied
635
revno = branch.revision_id_to_dotted_revno(rev_id)
636
except errors.NoSuchRevision:
637
# The revision must be outside of this branch
640
return '.'.join(str(n) for n in revno)
643
583
def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):
644
584
"""Is start_rev_id an obvious ancestor of end_rev_id?"""
645
585
if start_rev_id and end_rev_id:
647
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
648
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
649
except errors.NoSuchRevision:
650
# one or both is not in the branch; not obvious
586
start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)
587
end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)
652
588
if len(start_dotted) == 1 and len(end_dotted) == 1:
653
589
# both on mainline
654
590
return start_dotted[0] <= end_dotted[0]
662
# if either start or end is not specified then we use either the first or
663
# the last revision and *they* are obvious ancestors.
667
def _linear_view_revisions(branch, start_rev_id, end_rev_id,
668
exclude_common_ancestry=False):
601
def _linear_view_revisions(branch, start_rev_id, end_rev_id):
669
602
"""Calculate a sequence of revisions to view, newest to oldest.
671
604
:param start_rev_id: the lower revision-id
672
605
:param end_rev_id: the upper revision-id
673
:param exclude_common_ancestry: Whether the start_rev_id should be part of
674
the iterated revisions.
675
606
:return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
676
607
:raises _StartNotLinearAncestor: if a start_rev_id is specified but
677
is not found walking the left-hand history
608
is not found walking the left-hand history
679
610
br_revno, br_rev_id = branch.last_revision_info()
680
611
repo = branch.repository
736
662
depth_adjustment = merge_depth
737
663
if depth_adjustment:
738
664
if merge_depth < depth_adjustment:
739
# From now on we reduce the depth adjustement, this can be
740
# surprising for users. The alternative requires two passes
741
# which breaks the fast display of the first revision
743
665
depth_adjustment = merge_depth
744
666
merge_depth -= depth_adjustment
745
667
yield rev_id, '.'.join(map(str, revno)), merge_depth
748
@deprecated_function(deprecated_in((2, 2, 0)))
749
670
def calculate_view_revisions(branch, start_revision, end_revision, direction,
750
671
specific_fileid, generate_merge_revisions):
751
672
"""Calculate the revisions to view.
1366
1291
preferred_levels = 0
1368
1293
def __init__(self, to_file, show_ids=False, show_timezone='original',
1369
delta_format=None, levels=None, show_advice=False,
1370
to_exact_file=None, author_list_handler=None):
1294
delta_format=None, levels=None, show_advice=False):
1371
1295
"""Create a LogFormatter.
1373
1297
:param to_file: the file to output to
1374
:param to_exact_file: if set, gives an output stream to which
1375
non-Unicode diffs are written.
1376
1298
:param show_ids: if True, revision-ids are to be displayed
1377
1299
:param show_timezone: the timezone to use
1378
1300
:param delta_format: the level of delta information to display
1381
1303
let the log formatter decide.
1382
1304
:param show_advice: whether to show advice at the end of the
1384
:param author_list_handler: callable generating a list of
1385
authors to display for a given revision
1387
1307
self.to_file = to_file
1388
1308
# 'exact' stream used to show diff, it should print content 'as is'
1389
1309
# and should not try to decode/encode it to unicode to avoid bug #328007
1390
if to_exact_file is not None:
1391
self.to_exact_file = to_exact_file
1393
# XXX: somewhat hacky; this assumes it's a codec writer; it's better
1394
# for code that expects to get diffs to pass in the exact file
1396
self.to_exact_file = getattr(to_file, 'stream', to_file)
1310
self.to_exact_file = getattr(to_file, 'stream', to_file)
1397
1311
self.show_ids = show_ids
1398
1312
self.show_timezone = show_timezone
1399
1313
if delta_format is None:
1443
1356
def short_author(self, rev):
1444
return self.authors(rev, 'first', short=True, sep=', ')
1446
def authors(self, rev, who, short=False, sep=None):
1447
"""Generate list of authors, taking --authors option into account.
1449
The caller has to specify the name of a author list handler,
1450
as provided by the author list registry, using the ``who``
1451
argument. That name only sets a default, though: when the
1452
user selected a different author list generation using the
1453
``--authors`` command line switch, as represented by the
1454
``author_list_handler`` constructor argument, that value takes
1457
:param rev: The revision for which to generate the list of authors.
1458
:param who: Name of the default handler.
1459
:param short: Whether to shorten names to either name or address.
1460
:param sep: What separator to use for automatic concatenation.
1462
if self._author_list_handler is not None:
1463
# The user did specify --authors, which overrides the default
1464
author_list_handler = self._author_list_handler
1466
# The user didn't specify --authors, so we use the caller's default
1467
author_list_handler = author_list_registry.get(who)
1468
names = author_list_handler(rev)
1470
for i in range(len(names)):
1471
name, address = config.parse_username(names[i])
1477
names = sep.join(names)
1357
name, address = config.parse_username(rev.get_apparent_authors()[0])
1480
1362
def merge_marker(self, revision):
1481
1363
"""Get the merge marker to include in the output or '' if none."""
1488
def show_properties(self, revision, indent):
1489
"""Displays the custom properties returned by each registered handler.
1491
If a registered handler raises an error it is propagated.
1493
for line in self.custom_properties(revision):
1494
self.to_file.write("%s%s\n" % (indent, line))
1496
def custom_properties(self, revision):
1497
"""Format the custom properties returned by each registered handler.
1499
If a registered handler raises an error it is propagated.
1501
:return: a list of formatted lines (excluding trailing newlines)
1503
lines = self._foreign_info_properties(revision)
1504
for key, handler in properties_handler_registry.iteritems():
1505
lines.extend(self._format_properties(handler(revision)))
1508
def _foreign_info_properties(self, rev):
1370
def show_foreign_info(self, rev, indent):
1509
1371
"""Custom log displayer for foreign revision identifiers.
1511
1373
:param rev: Revision object.
1513
1375
# Revision comes directly from a foreign repository
1514
1376
if isinstance(rev, foreign.ForeignRevision):
1515
return self._format_properties(
1516
rev.mapping.vcs.show_foreign_revid(rev.foreign_revid))
1377
self._write_properties(indent, rev.mapping.vcs.show_foreign_revid(
1518
1381
# Imported foreign revision revision ids always contain :
1519
1382
if not ":" in rev.revision_id:
1522
1385
# Revision was once imported from a foreign repository
1524
1387
foreign_revid, mapping = \
1525
1388
foreign.foreign_vcs_registry.parse_revision_id(rev.revision_id)
1526
1389
except errors.InvalidRevisionId:
1529
return self._format_properties(
1392
self._write_properties(indent,
1530
1393
mapping.vcs.show_foreign_revid(foreign_revid))
1532
def _format_properties(self, properties):
1395
def show_properties(self, revision, indent):
1396
"""Displays the custom properties returned by each registered handler.
1398
If a registered handler raises an error it is propagated.
1400
for key, handler in properties_handler_registry.iteritems():
1401
self._write_properties(indent, handler(revision))
1403
def _write_properties(self, indent, properties):
1534
1404
for key, value in properties.items():
1535
lines.append(key + ': ' + value)
1405
self.to_file.write(indent + key + ': ' + value + '\n')
1538
1407
def show_diff(self, to_file, diff, indent):
1539
1408
for l in diff.rstrip().split('\n'):
1540
1409
to_file.write(indent + '%s\n' % (l,))
1543
# Separator between revisions in long format
1544
_LONG_SEP = '-' * 60
1547
1412
class LongLogFormatter(LogFormatter):
1549
1414
supports_merge_revisions = True
1552
1417
supports_tags = True
1553
1418
supports_diff = True
1555
def __init__(self, *args, **kwargs):
1556
super(LongLogFormatter, self).__init__(*args, **kwargs)
1557
if self.show_timezone == 'original':
1558
self.date_string = self._date_string_original_timezone
1560
self.date_string = self._date_string_with_timezone
1562
def _date_string_with_timezone(self, rev):
1563
return format_date(rev.timestamp, rev.timezone or 0,
1566
def _date_string_original_timezone(self, rev):
1567
return format_date_with_offset_in_original_timezone(rev.timestamp,
1570
1420
def log_revision(self, revision):
1571
1421
"""Log a revision, either merged or not."""
1572
1422
indent = ' ' * revision.merge_depth
1423
to_file = self.to_file
1424
to_file.write(indent + '-' * 60 + '\n')
1574
1425
if revision.revno is not None:
1575
lines.append('revno: %s%s' % (revision.revno,
1426
to_file.write(indent + 'revno: %s%s\n' % (revision.revno,
1576
1427
self.merge_marker(revision)))
1577
1428
if revision.tags:
1578
lines.append('tags: %s' % (', '.join(revision.tags)))
1579
if self.show_ids or revision.revno is None:
1580
lines.append('revision-id: %s' % (revision.rev.revision_id,))
1429
to_file.write(indent + 'tags: %s\n' % (', '.join(revision.tags)))
1581
1430
if self.show_ids:
1431
to_file.write(indent + 'revision-id: ' + revision.rev.revision_id)
1582
1433
for parent_id in revision.rev.parent_ids:
1583
lines.append('parent: %s' % (parent_id,))
1584
lines.extend(self.custom_properties(revision.rev))
1434
to_file.write(indent + 'parent: %s\n' % (parent_id,))
1435
self.show_foreign_info(revision.rev, indent)
1436
self.show_properties(revision.rev, indent)
1586
1438
committer = revision.rev.committer
1587
authors = self.authors(revision.rev, 'all')
1439
authors = revision.rev.get_apparent_authors()
1588
1440
if authors != [committer]:
1589
lines.append('author: %s' % (", ".join(authors),))
1590
lines.append('committer: %s' % (committer,))
1441
to_file.write(indent + 'author: %s\n' % (", ".join(authors),))
1442
to_file.write(indent + 'committer: %s\n' % (committer,))
1592
1444
branch_nick = revision.rev.properties.get('branch-nick', None)
1593
1445
if branch_nick is not None:
1594
lines.append('branch nick: %s' % (branch_nick,))
1596
lines.append('timestamp: %s' % (self.date_string(revision.rev),))
1598
lines.append('message:')
1446
to_file.write(indent + 'branch nick: %s\n' % (branch_nick,))
1448
date_str = format_date(revision.rev.timestamp,
1449
revision.rev.timezone or 0,
1451
to_file.write(indent + 'timestamp: %s\n' % (date_str,))
1453
to_file.write(indent + 'message:\n')
1599
1454
if not revision.rev.message:
1600
lines.append(' (no message)')
1455
to_file.write(indent + ' (no message)\n')
1602
1457
message = revision.rev.message.rstrip('\r\n')
1603
1458
for l in message.split('\n'):
1604
lines.append(' %s' % (l,))
1606
# Dump the output, appending the delta and diff if requested
1607
to_file = self.to_file
1608
to_file.write("%s%s\n" % (indent, ('\n' + indent).join(lines)))
1459
to_file.write(indent + ' %s\n' % (l,))
1609
1460
if revision.delta is not None:
1610
# Use the standard status output to display changes
1611
from bzrlib.delta import report_delta
1612
report_delta(to_file, revision.delta, short_status=False,
1613
show_ids=self.show_ids, indent=indent)
1461
# We don't respect delta_format for compatibility
1462
revision.delta.show(to_file, self.show_ids, indent=indent,
1614
1464
if revision.diff is not None:
1615
1465
to_file.write(indent + 'diff:\n')
1617
1466
# Note: we explicitly don't indent the diff (relative to the
1618
1467
# revision information) so that the output can be fed to patch -p0
1619
1468
self.show_diff(self.to_exact_file, revision.diff, indent)
1620
self.to_exact_file.flush()
1622
1470
def get_advice_separator(self):
1623
1471
"""Get the text separating the log from the closing advice."""
1661
1509
if revision.tags:
1662
1510
tags = ' {%s}' % (', '.join(revision.tags))
1663
1511
to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,
1664
revision.revno or "", self.short_author(revision.rev),
1512
revision.revno, self.short_author(revision.rev),
1665
1513
format_date(revision.rev.timestamp,
1666
1514
revision.rev.timezone or 0,
1667
1515
self.show_timezone, date_fmt="%Y-%m-%d",
1668
1516
show_offset=False),
1669
1517
tags, self.merge_marker(revision)))
1518
self.show_foreign_info(revision.rev, indent+offset)
1670
1519
self.show_properties(revision.rev, indent+offset)
1671
if self.show_ids or revision.revno is None:
1672
1521
to_file.write(indent + offset + 'revision-id:%s\n'
1673
1522
% (revision.rev.revision_id,))
1674
1523
if not revision.rev.message:
1679
1528
to_file.write(indent + offset + '%s\n' % (l,))
1681
1530
if revision.delta is not None:
1682
# Use the standard status output to display changes
1683
from bzrlib.delta import report_delta
1684
report_delta(to_file, revision.delta,
1685
short_status=self.delta_format==1,
1686
show_ids=self.show_ids, indent=indent + offset)
1531
revision.delta.show(to_file, self.show_ids, indent=indent + offset,
1532
short_status=self.delta_format==1)
1687
1533
if revision.diff is not None:
1688
1534
self.show_diff(self.to_exact_file, revision.diff, ' ')
1689
1535
to_file.write('\n')
1836
1677
raise errors.BzrCommandError("unknown log formatter: %r" % name)
1839
def author_list_all(rev):
1840
return rev.get_apparent_authors()[:]
1843
def author_list_first(rev):
1844
lst = rev.get_apparent_authors()
1851
def author_list_committer(rev):
1852
return [rev.committer]
1855
author_list_registry = registry.Registry()
1857
author_list_registry.register('all', author_list_all,
1860
author_list_registry.register('first', author_list_first,
1863
author_list_registry.register('committer', author_list_committer,
1867
1680
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
1868
1681
# deprecated; for compatibility
1869
1682
lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
2030
1843
:param file_list: the list of paths given on the command line;
2031
1844
the first of these can be a branch location or a file path,
2032
1845
the remainder must be file paths
2033
:param add_cleanup: When the branch returned is read locked,
2034
an unlock call will be queued to the cleanup.
2035
1846
:return: (branch, info_list, start_rev_info, end_rev_info) where
2036
1847
info_list is a list of (relative_path, file_id, kind) tuples where
2037
1848
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
2038
branch will be read-locked.
2040
from builtins import _get_revision_range
1850
from builtins import _get_revision_range, safe_relpath_files
2041
1851
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
2042
add_cleanup(b.lock_read().unlock)
2043
1852
# XXX: It's damn messy converting a list of paths to relative paths when
2044
1853
# those paths might be deleted ones, they might be on a case-insensitive
2045
1854
# filesystem and/or they might be in silly locations (like another branch).
2125
1934
properties_handler_registry = registry.Registry()
2127
# Use the properties handlers to print out bug information if available
2128
def _bugs_properties_handler(revision):
2129
if revision.properties.has_key('bugs'):
2130
bug_lines = revision.properties['bugs'].split('\n')
2131
bug_rows = [line.split(' ', 1) for line in bug_lines]
2132
fixed_bug_urls = [row[0] for row in bug_rows if
2133
len(row) > 1 and row[1] == 'fixed']
2136
return {'fixes bug(s)': ' '.join(fixed_bug_urls)}
2139
properties_handler_registry.register('bugs_properties_handler',
2140
_bugs_properties_handler)
2143
1937
# adapters which revision ids to log are filtered. When log is called, the
2144
1938
# log_rev_iterator is adapted through each of these factory methods.
added
removed
bzrlib/log.py
