126
129
raise errors.UnstackableRepositoryFormat(self.repository._format,
127
130
self.repository.base)
129
def _extend_partial_history(self, stop_index=None, stop_revision=None):
130
"""Extend the partial history to include a given index
132
If a stop_index is supplied, stop when that index has been reached.
133
If a stop_revision is supplied, stop when that revision is
134
encountered. Otherwise, stop when the beginning of history is
137
:param stop_index: The index which should be present. When it is
138
present, history extension will stop.
139
:param stop_revision: The revision id which should be present. When
140
it is encountered, history extension will stop.
142
if len(self._partial_revision_history_cache) == 0:
143
self._partial_revision_history_cache = [self.last_revision()]
144
repository._iter_for_revno(
145
self.repository, self._partial_revision_history_cache,
146
stop_index=stop_index, stop_revision=stop_revision)
147
if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
148
self._partial_revision_history_cache.pop()
150
def _get_check_refs(self):
151
"""Get the references needed for check().
155
revid = self.last_revision()
156
return [('revision-existence', revid), ('lefthand-distance', revid)]
159
133
def open(base, _unsupported=False, possible_transports=None):
160
134
"""Open the branch rooted at base.
446
418
# start_revision_id.
447
419
if self._merge_sorted_revisions_cache is None:
448
420
last_revision = self.last_revision()
449
known_graph = self.repository.get_known_graph_ancestry(
451
self._merge_sorted_revisions_cache = known_graph.merge_sort(
421
graph = self.repository.get_graph()
422
parent_map = dict(((key, value) for key, value in
423
graph.iter_ancestry([last_revision]) if value is not None))
424
revision_graph = repository._strip_NULL_ghosts(parent_map)
425
revs = tsort.merge_sort(revision_graph, last_revision, None,
427
# Drop the sequence # before caching
428
self._merge_sorted_revisions_cache = [r[1:] for r in revs]
453
430
filtered = self._filter_merge_sorted_revisions(
454
431
self._merge_sorted_revisions_cache, start_revision_id,
455
432
stop_revision_id, stop_rule)
456
# Make sure we don't return revisions that are not part of the
457
# start_revision_id ancestry.
458
filtered = self._filter_start_non_ancestors(filtered)
459
433
if direction == 'reverse':
461
435
if direction == 'forward':
468
442
"""Iterate over an inclusive range of sorted revisions."""
469
443
rev_iter = iter(merge_sorted_revisions)
470
444
if start_revision_id is not None:
471
for node in rev_iter:
472
rev_id = node.key[-1]
445
for rev_id, depth, revno, end_of_merge in rev_iter:
473
446
if rev_id != start_revision_id:
476
449
# The decision to include the start or not
477
450
# depends on the stop_rule if a stop is provided
478
# so pop this node back into the iterator
479
rev_iter = chain(iter([node]), rev_iter)
452
iter([(rev_id, depth, revno, end_of_merge)]),
481
455
if stop_revision_id is None:
483
for node in rev_iter:
484
rev_id = node.key[-1]
485
yield (rev_id, node.merge_depth, node.revno,
456
for rev_id, depth, revno, end_of_merge in rev_iter:
457
yield rev_id, depth, revno, end_of_merge
487
458
elif stop_rule == 'exclude':
488
for node in rev_iter:
489
rev_id = node.key[-1]
459
for rev_id, depth, revno, end_of_merge in rev_iter:
490
460
if rev_id == stop_revision_id:
492
yield (rev_id, node.merge_depth, node.revno,
462
yield rev_id, depth, revno, end_of_merge
494
463
elif stop_rule == 'include':
495
for node in rev_iter:
496
rev_id = node.key[-1]
497
yield (rev_id, node.merge_depth, node.revno,
464
for rev_id, depth, revno, end_of_merge in rev_iter:
465
yield rev_id, depth, revno, end_of_merge
499
466
if rev_id == stop_revision_id:
501
elif stop_rule == 'with-merges-without-common-ancestry':
502
# We want to exclude all revisions that are already part of the
503
# stop_revision_id ancestry.
504
graph = self.repository.get_graph()
505
ancestors = graph.find_unique_ancestors(start_revision_id,
507
for node in rev_iter:
508
rev_id = node.key[-1]
509
if rev_id not in ancestors:
511
yield (rev_id, node.merge_depth, node.revno,
513
468
elif stop_rule == 'with-merges':
514
469
stop_rev = self.repository.get_revision(stop_revision_id)
515
470
if stop_rev.parent_ids:
516
471
left_parent = stop_rev.parent_ids[0]
518
473
left_parent = _mod_revision.NULL_REVISION
519
# left_parent is the actual revision we want to stop logging at,
520
# since we want to show the merged revisions after the stop_rev too
521
reached_stop_revision_id = False
522
revision_id_whitelist = []
523
for node in rev_iter:
524
rev_id = node.key[-1]
474
for rev_id, depth, revno, end_of_merge in rev_iter:
525
475
if rev_id == left_parent:
526
# reached the left parent after the stop_revision
528
if (not reached_stop_revision_id or
529
rev_id in revision_id_whitelist):
530
yield (rev_id, node.merge_depth, node.revno,
532
if reached_stop_revision_id or rev_id == stop_revision_id:
533
# only do the merged revs of rev_id from now on
534
rev = self.repository.get_revision(rev_id)
536
reached_stop_revision_id = True
537
revision_id_whitelist.extend(rev.parent_ids)
477
yield rev_id, depth, revno, end_of_merge
539
479
raise ValueError('invalid stop_rule %r' % stop_rule)
541
def _filter_start_non_ancestors(self, rev_iter):
542
# If we started from a dotted revno, we want to consider it as a tip
543
# and don't want to yield revisions that are not part of its
544
# ancestry. Given the order guaranteed by the merge sort, we will see
545
# uninteresting descendants of the first parent of our tip before the
547
first = rev_iter.next()
548
(rev_id, merge_depth, revno, end_of_merge) = first
551
# We start at a mainline revision so by definition, all others
552
# revisions in rev_iter are ancestors
553
for node in rev_iter:
558
pmap = self.repository.get_parent_map([rev_id])
559
parents = pmap.get(rev_id, [])
561
whitelist.update(parents)
563
# If there is no parents, there is nothing of interest left
565
# FIXME: It's hard to test this scenario here as this code is never
566
# called in that case. -- vila 20100322
569
for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
571
if rev_id in whitelist:
572
pmap = self.repository.get_parent_map([rev_id])
573
parents = pmap.get(rev_id, [])
574
whitelist.remove(rev_id)
575
whitelist.update(parents)
577
# We've reached the mainline, there is nothing left to
581
# A revision that is not part of the ancestry of our
584
yield (rev_id, merge_depth, revno, end_of_merge)
586
481
def leave_lock_in_place(self):
587
482
"""Tell this branch object not to release the physical lock when this
588
483
object is unlocked.
758
640
except (errors.NotStacked, errors.UnstackableBranchFormat,
759
641
errors.UnstackableRepositoryFormat):
644
# XXX: Lock correctness - should unlock our old repo if we were
646
# repositories don't offer an interface to remove fallback
647
# repositories today; take the conceptually simpler option and just
649
self.repository = self.bzrdir.find_repository()
650
self.repository.lock_write()
651
# for every revision reference the branch has, ensure it is pulled
653
source_repository = self._get_fallback_repository(old_url)
654
for revision_id in chain([self.last_revision()],
655
self.tags.get_reverse_tag_dict()):
656
self.repository.fetch(source_repository, revision_id,
763
self._activate_fallback_location(url)
659
self._activate_fallback_location(url, 'write')
764
660
# write this out after the repository is stacked to avoid setting a
765
661
# stacked config that doesn't work.
766
662
self._set_config_location('stacked_on_location', url)
769
"""Change a branch to be unstacked, copying data as needed.
771
Don't call this directly, use set_stacked_on_url(None).
773
pb = ui.ui_factory.nested_progress_bar()
775
pb.update("Unstacking")
776
# The basic approach here is to fetch the tip of the branch,
777
# including all available ghosts, from the existing stacked
778
# repository into a new repository object without the fallbacks.
780
# XXX: See <https://launchpad.net/bugs/397286> - this may not be
781
# correct for CHKMap repostiories
782
old_repository = self.repository
783
if len(old_repository._fallback_repositories) != 1:
784
raise AssertionError("can't cope with fallback repositories "
785
"of %r" % (self.repository,))
786
# unlock it, including unlocking the fallback
787
old_repository.unlock()
788
old_repository.lock_read()
790
# Repositories don't offer an interface to remove fallback
791
# repositories today; take the conceptually simpler option and just
792
# reopen it. We reopen it starting from the URL so that we
793
# get a separate connection for RemoteRepositories and can
794
# stream from one of them to the other. This does mean doing
795
# separate SSH connection setup, but unstacking is not a
796
# common operation so it's tolerable.
797
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
798
new_repository = new_bzrdir.find_repository()
799
self.repository = new_repository
800
if self.repository._fallback_repositories:
801
raise AssertionError("didn't expect %r to have "
802
"fallback_repositories"
803
% (self.repository,))
804
# this is not paired with an unlock because it's just restoring
805
# the previous state; the lock's released when set_stacked_on_url
807
self.repository.lock_write()
808
# XXX: If you unstack a branch while it has a working tree
809
# with a pending merge, the pending-merged revisions will no
810
# longer be present. You can (probably) revert and remerge.
812
# XXX: This only fetches up to the tip of the repository; it
813
# doesn't bring across any tags. That's fairly consistent
814
# with how branch works, but perhaps not ideal.
815
self.repository.fetch(old_repository,
816
revision_id=self.last_revision(),
819
old_repository.unlock()
823
665
def _set_tags_bytes(self, bytes):
824
666
"""Mirror method for _get_tags_bytes.
991
835
except ValueError:
992
836
raise errors.NoSuchRevision(self, revision_id)
995
838
def get_rev_id(self, revno, history=None):
996
839
"""Find the revision id of the specified revno."""
998
841
return _mod_revision.NULL_REVISION
999
last_revno, last_revid = self.last_revision_info()
1000
if revno == last_revno:
1002
if revno <= 0 or revno > last_revno:
843
history = self.revision_history()
844
if revno <= 0 or revno > len(history):
1003
845
raise errors.NoSuchRevision(self, revno)
1004
distance_from_last = last_revno - revno
1005
if len(self._partial_revision_history_cache) <= distance_from_last:
1006
self._extend_partial_history(distance_from_last)
1007
return self._partial_revision_history_cache[distance_from_last]
846
return history[revno - 1]
1009
848
@needs_write_lock
1010
849
def pull(self, source, overwrite=False, stop_revision=None,
1245
1084
source_revno, source_revision_id = self.last_revision_info()
1246
1085
if revision_id is None:
1247
1086
revno, revision_id = source_revno, source_revision_id
1087
elif source_revision_id == revision_id:
1088
# we know the revno without needing to walk all of history
1089
revno = source_revno
1249
graph = self.repository.get_graph()
1251
revno = graph.find_distance_to_null(revision_id,
1252
[(source_revision_id, source_revno)])
1253
except errors.GhostRevisionsHaveNoRevno:
1254
# Default to 1, if we can't find anything else
1091
# To figure out the revno for a random revision, we need to build
1092
# the revision history, and count its length.
1093
# We don't care about the order, just how long it is.
1094
# Alternatively, we could start at the current location, and count
1095
# backwards. But there is no guarantee that we will find it since
1096
# it may be a merged revision.
1097
revno = len(list(self.repository.iter_reverse_revision_history(
1256
1099
destination.set_last_revision_info(revno, revision_id)
1258
1101
@needs_read_lock
1302
1145
Callers will typically also want to check the repository.
1304
:param refs: Calculated refs for this branch as specified by
1305
branch._get_check_refs()
1306
1147
:return: A BranchCheckResult.
1308
result = BranchCheckResult(self)
1149
mainline_parent_id = None
1309
1150
last_revno, last_revision_id = self.last_revision_info()
1310
actual_revno = refs[('lefthand-distance', last_revision_id)]
1311
if actual_revno != last_revno:
1312
result.errors.append(errors.BzrCheckError(
1313
'revno does not match len(mainline) %s != %s' % (
1314
last_revno, actual_revno)))
1315
# TODO: We should probably also check that self.revision_history
1316
# matches the repository for older branch formats.
1317
# If looking for the code that cross-checks repository parents against
1318
# the iter_reverse_revision_history output, that is now a repository
1151
real_rev_history = list(self.repository.iter_reverse_revision_history(
1153
real_rev_history.reverse()
1154
if len(real_rev_history) != last_revno:
1155
raise errors.BzrCheckError('revno does not match len(mainline)'
1156
' %s != %s' % (last_revno, len(real_rev_history)))
1157
# TODO: We should probably also check that real_rev_history actually
1158
# matches self.revision_history()
1159
for revision_id in real_rev_history:
1161
revision = self.repository.get_revision(revision_id)
1162
except errors.NoSuchRevision, e:
1163
raise errors.BzrCheckError("mainline revision {%s} not in repository"
1165
# In general the first entry on the revision history has no parents.
1166
# But it's not illegal for it to have parents listed; this can happen
1167
# in imports from Arch when the parents weren't reachable.
1168
if mainline_parent_id is not None:
1169
if mainline_parent_id not in revision.parent_ids:
1170
raise errors.BzrCheckError("previous revision {%s} not listed among "
1172
% (mainline_parent_id, revision_id))
1173
mainline_parent_id = revision_id
1174
return BranchCheckResult(self)
1322
1176
def _get_checkout_format(self):
1323
1177
"""Return the most suitable metadir for a checkout of this branch.
1554
1400
"""Return the short format description for this format."""
1555
1401
raise NotImplementedError(self.get_format_description)
1557
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1558
hooks = Branch.hooks['post_branch_init']
1561
params = BranchInitHookParams(self, a_bzrdir, name, branch)
1565
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1566
lock_type='metadir', set_format=True):
1403
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
1567
1405
"""Initialize a branch in a bzrdir, with specified files
1569
1407
:param a_bzrdir: The bzrdir to initialize the branch in
1570
1408
:param utf8_files: The files to create as a list of
1571
1409
(filename, content) tuples
1572
:param name: Name of colocated branch to create, if any
1573
1410
:param set_format: If True, set the format with
1574
1411
self.get_format_string. (BzrBranch4 has its format set
1576
1413
:return: a branch in this format
1578
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1579
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1415
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1416
branch_transport = a_bzrdir.get_branch_transport(self)
1581
1418
'metadir': ('lock', lockdir.LockDir),
1582
1419
'branch4': ('branch-lock', lockable_files.TransportLock),
1765
1592
"multiple hooks installed for transform_fallback_location, "
1766
1593
"all are called with the url returned from the previous hook."
1767
1594
"The order is however undefined.", (1, 9), None))
1768
self.create_hook(HookPoint('automatic_tag_name',
1769
"Called to determine an automatic tag name for a revision."
1770
"automatic_tag_name is called with (branch, revision_id) and "
1771
"should return a tag name or None if no tag name could be "
1772
"determined. The first non-None tag name returned will be used.",
1774
self.create_hook(HookPoint('post_branch_init',
1775
"Called after new branch initialization completes. "
1776
"post_branch_init is called with a "
1777
"bzrlib.branch.BranchInitHookParams. "
1778
"Note that init, branch and checkout (both heavyweight and "
1779
"lightweight) will all trigger this hook.", (2, 2), None))
1780
self.create_hook(HookPoint('post_switch',
1781
"Called after a checkout switches branch. "
1782
"post_switch is called with a "
1783
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1787
1597
# install the default hooks into the Branch class.
1826
1636
self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1829
class BranchInitHookParams(object):
1830
"""Object holding parameters passed to *_branch_init hooks.
1832
There are 4 fields that hooks may wish to access:
1834
:ivar format: the branch format
1835
:ivar bzrdir: the BzrDir where the branch will be/has been initialized
1836
:ivar name: name of colocated branch, if any (or None)
1837
:ivar branch: the branch created
1839
Note that for lightweight checkouts, the bzrdir and format fields refer to
1840
the checkout, hence they are different from the corresponding fields in
1841
branch, which refer to the original branch.
1844
def __init__(self, format, a_bzrdir, name, branch):
1845
"""Create a group of BranchInitHook parameters.
1847
:param format: the branch format
1848
:param a_bzrdir: the BzrDir where the branch will be/has been
1850
:param name: name of colocated branch, if any (or None)
1851
:param branch: the branch created
1853
Note that for lightweight checkouts, the bzrdir and format fields refer
1854
to the checkout, hence they are different from the corresponding fields
1855
in branch, which refer to the original branch.
1857
self.format = format
1858
self.bzrdir = a_bzrdir
1860
self.branch = branch
1862
def __eq__(self, other):
1863
return self.__dict__ == other.__dict__
1867
return "<%s of %s>" % (self.__class__.__name__, self.branch)
1869
return "<%s of format:%s bzrdir:%s>" % (
1870
self.__class__.__name__, self.branch,
1871
self.format, self.bzrdir)
1874
class SwitchHookParams(object):
1875
"""Object holding parameters passed to *_switch hooks.
1877
There are 4 fields that hooks may wish to access:
1879
:ivar control_dir: BzrDir of the checkout to change
1880
:ivar to_branch: branch that the checkout is to reference
1881
:ivar force: skip the check for local commits in a heavy checkout
1882
:ivar revision_id: revision ID to switch to (or None)
1885
def __init__(self, control_dir, to_branch, force, revision_id):
1886
"""Create a group of SwitchHook parameters.
1888
:param control_dir: BzrDir of the checkout to change
1889
:param to_branch: branch that the checkout is to reference
1890
:param force: skip the check for local commits in a heavy checkout
1891
:param revision_id: revision ID to switch to (or None)
1893
self.control_dir = control_dir
1894
self.to_branch = to_branch
1896
self.revision_id = revision_id
1898
def __eq__(self, other):
1899
return self.__dict__ == other.__dict__
1902
return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1903
self.control_dir, self.to_branch,
1907
1639
class BzrBranchFormat4(BranchFormat):
1908
1640
"""Bzr branch format 4.
1962
1693
return self.get_format_string()
1964
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1695
def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
1965
1696
"""See BranchFormat.open()."""
1967
format = BranchFormat.find_format(a_bzrdir, name=name)
1698
format = BranchFormat.find_format(a_bzrdir)
1968
1699
if format.__class__ != self.__class__:
1969
1700
raise AssertionError("wrong format %r found for %r" %
1970
1701
(format, self))
1971
transport = a_bzrdir.get_branch_transport(None, name=name)
1703
transport = a_bzrdir.get_branch_transport(None)
1973
1704
control_files = lockable_files.LockableFiles(transport, 'lock',
1974
1705
lockdir.LockDir)
1975
1706
return self._branch_class()(_format=self,
1976
1707
_control_files=control_files,
1978
1708
a_bzrdir=a_bzrdir,
1979
1709
_repository=a_bzrdir.find_repository(),
1980
1710
ignore_fallbacks=ignore_fallbacks)
1981
1711
except errors.NoSuchFile:
1982
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1712
raise errors.NotBranchError(path=transport.base)
1984
1714
def __init__(self):
1985
1715
super(BranchFormatMetadir, self).__init__()
2160
1882
def get_reference(self, a_bzrdir):
2161
1883
"""See BranchFormat.get_reference()."""
2162
1884
transport = a_bzrdir.get_branch_transport(None)
2163
return transport.get_bytes('location')
1885
return transport.get('location').read()
2165
1887
def set_reference(self, a_bzrdir, to_branch):
2166
1888
"""See BranchFormat.set_reference()."""
2167
1889
transport = a_bzrdir.get_branch_transport(None)
2168
1890
location = transport.put_bytes('location', to_branch.base)
2170
def initialize(self, a_bzrdir, name=None, target_branch=None):
1892
def initialize(self, a_bzrdir, target_branch=None):
2171
1893
"""Create a branch of this format in a_bzrdir."""
2172
1894
if target_branch is None:
2173
1895
# this format does not implement branch itself, thus the implicit
2174
1896
# creation contract must see it as uninitializable
2175
1897
raise errors.UninitializableFormat(self)
2176
mutter('creating branch reference in %s', a_bzrdir.user_url)
2177
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1898
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1899
branch_transport = a_bzrdir.get_branch_transport(self)
2178
1900
branch_transport.put_bytes('location',
2179
target_branch.bzrdir.user_url)
1901
target_branch.bzrdir.root_transport.base)
2180
1902
branch_transport.put_bytes('format', self.get_format_string())
2182
a_bzrdir, name, _found=True,
1904
a_bzrdir, _found=True,
2183
1905
possible_transports=[target_branch.bzrdir.root_transport])
2184
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2187
1907
def __init__(self):
2188
1908
super(BranchReferenceFormat, self).__init__()
2194
1914
def clone(to_bzrdir, revision_id=None,
2195
1915
repository_policy=None):
2196
1916
"""See Branch.clone()."""
2197
return format.initialize(to_bzrdir, target_branch=a_branch)
1917
return format.initialize(to_bzrdir, a_branch)
2198
1918
# cannot obey revision_id limits when cloning a reference ...
2199
1919
# FIXME RBC 20060210 either nuke revision_id for clone, or
2200
1920
# emit some sort of warning/error to the caller ?!
2203
def open(self, a_bzrdir, name=None, _found=False, location=None,
1923
def open(self, a_bzrdir, _found=False, location=None,
2204
1924
possible_transports=None, ignore_fallbacks=False):
2205
1925
"""Return the branch that the branch reference in a_bzrdir points at.
2207
1927
:param a_bzrdir: A BzrDir that contains a branch.
2208
:param name: Name of colocated branch to open, if any
2209
1928
:param _found: a private parameter, do not use it. It is used to
2210
1929
indicate if format probing has already be done.
2211
1930
:param ignore_fallbacks: when set, no fallback branches will be opened
2277
1995
:ivar repository: Repository for this branch.
2278
1996
:ivar base: The url of the base directory for this branch; the one
2279
1997
containing the .bzr directory.
2280
:ivar name: Optional colocated branch name as it exists in the control
2284
2000
def __init__(self, _format=None,
2285
_control_files=None, a_bzrdir=None, name=None,
2286
_repository=None, ignore_fallbacks=False):
2001
_control_files=None, a_bzrdir=None, _repository=None,
2002
ignore_fallbacks=False):
2287
2003
"""Create new branch object at a particular location."""
2288
2004
if a_bzrdir is None:
2289
2005
raise ValueError('a_bzrdir must be supplied')
2291
2007
self.bzrdir = a_bzrdir
2292
2008
self._base = self.bzrdir.transport.clone('..').base
2294
2009
# XXX: We should be able to just do
2295
2010
# self.base = self.bzrdir.root_transport.base
2296
2011
# but this does not quite work yet -- mbp 20080522
2661
2365
raise AssertionError(
2662
2366
"'transform_fallback_location' hook %s returned "
2663
2367
"None, not a URL." % hook_name)
2664
self._activate_fallback_location(url)
2368
self._activate_fallback_location(url, None)
2666
2370
def __init__(self, *args, **kwargs):
2667
2371
self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2668
2372
super(BzrBranch8, self).__init__(*args, **kwargs)
2669
2373
self._last_revision_info_cache = None
2374
self._partial_revision_history_cache = []
2670
2375
self._reference_info = None
2672
2377
def _clear_cached_state(self):
2673
2378
super(BzrBranch8, self)._clear_cached_state()
2674
2379
self._last_revision_info_cache = None
2380
self._partial_revision_history_cache = []
2675
2381
self._reference_info = None
2677
2383
def _last_revision_info(self):
2733
2439
self._extend_partial_history(stop_index=last_revno-1)
2734
2440
return list(reversed(self._partial_revision_history_cache))
2442
def _extend_partial_history(self, stop_index=None, stop_revision=None):
2443
"""Extend the partial history to include a given index
2445
If a stop_index is supplied, stop when that index has been reached.
2446
If a stop_revision is supplied, stop when that revision is
2447
encountered. Otherwise, stop when the beginning of history is
2450
:param stop_index: The index which should be present. When it is
2451
present, history extension will stop.
2452
:param revision_id: The revision id which should be present. When
2453
it is encountered, history extension will stop.
2455
repo = self.repository
2456
if len(self._partial_revision_history_cache) == 0:
2457
iterator = repo.iter_reverse_revision_history(self.last_revision())
2459
start_revision = self._partial_revision_history_cache[-1]
2460
iterator = repo.iter_reverse_revision_history(start_revision)
2461
#skip the last revision in the list
2462
next_revision = iterator.next()
2463
for revision_id in iterator:
2464
self._partial_revision_history_cache.append(revision_id)
2465
if (stop_index is not None and
2466
len(self._partial_revision_history_cache) > stop_index):
2468
if revision_id == stop_revision:
2736
2471
def _write_revision_history(self, history):
2737
2472
"""Factored out of set_revision_history.
added
removed
bzrlib/branch.py
