129
126
raise errors.UnstackableRepositoryFormat(self.repository._format,
130
127
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)]
133
159
def open(base, _unsupported=False, possible_transports=None):
134
160
"""Open the branch rooted at base.
418
446
# start_revision_id.
419
447
if self._merge_sorted_revisions_cache is None:
420
448
last_revision = self.last_revision()
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]
449
known_graph = self.repository.get_known_graph_ancestry(
451
self._merge_sorted_revisions_cache = known_graph.merge_sort(
430
453
filtered = self._filter_merge_sorted_revisions(
431
454
self._merge_sorted_revisions_cache, start_revision_id,
432
455
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)
433
459
if direction == 'reverse':
435
461
if direction == 'forward':
442
468
"""Iterate over an inclusive range of sorted revisions."""
443
469
rev_iter = iter(merge_sorted_revisions)
444
470
if start_revision_id is not None:
445
for rev_id, depth, revno, end_of_merge in rev_iter:
471
for node in rev_iter:
472
rev_id = node.key[-1]
446
473
if rev_id != start_revision_id:
449
476
# The decision to include the start or not
450
477
# depends on the stop_rule if a stop is provided
452
iter([(rev_id, depth, revno, end_of_merge)]),
478
# so pop this node back into the iterator
479
rev_iter = chain(iter([node]), rev_iter)
455
481
if stop_revision_id is None:
456
for rev_id, depth, revno, end_of_merge in rev_iter:
457
yield rev_id, depth, revno, end_of_merge
483
for node in rev_iter:
484
rev_id = node.key[-1]
485
yield (rev_id, node.merge_depth, node.revno,
458
487
elif stop_rule == 'exclude':
459
for rev_id, depth, revno, end_of_merge in rev_iter:
488
for node in rev_iter:
489
rev_id = node.key[-1]
460
490
if rev_id == stop_revision_id:
462
yield rev_id, depth, revno, end_of_merge
492
yield (rev_id, node.merge_depth, node.revno,
463
494
elif stop_rule == 'include':
464
for rev_id, depth, revno, end_of_merge in rev_iter:
465
yield rev_id, depth, revno, end_of_merge
495
for node in rev_iter:
496
rev_id = node.key[-1]
497
yield (rev_id, node.merge_depth, node.revno,
466
499
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,
468
513
elif stop_rule == 'with-merges':
469
514
stop_rev = self.repository.get_revision(stop_revision_id)
470
515
if stop_rev.parent_ids:
471
516
left_parent = stop_rev.parent_ids[0]
473
518
left_parent = _mod_revision.NULL_REVISION
474
for rev_id, depth, revno, end_of_merge in rev_iter:
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]
475
525
if rev_id == left_parent:
526
# reached the left parent after the stop_revision
477
yield rev_id, depth, revno, end_of_merge
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)
479
539
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)
481
586
def leave_lock_in_place(self):
482
587
"""Tell this branch object not to release the physical lock when this
483
588
object is unlocked.
640
758
except (errors.NotStacked, errors.UnstackableBranchFormat,
641
759
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,
659
self._activate_fallback_location(url, 'write')
763
self._activate_fallback_location(url)
660
764
# write this out after the repository is stacked to avoid setting a
661
765
# stacked config that doesn't work.
662
766
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()
665
823
def _set_tags_bytes(self, bytes):
666
824
"""Mirror method for _get_tags_bytes.
835
991
except ValueError:
836
992
raise errors.NoSuchRevision(self, revision_id)
838
995
def get_rev_id(self, revno, history=None):
839
996
"""Find the revision id of the specified revno."""
841
998
return _mod_revision.NULL_REVISION
843
history = self.revision_history()
844
if revno <= 0 or revno > len(history):
999
last_revno, last_revid = self.last_revision_info()
1000
if revno == last_revno:
1002
if revno <= 0 or revno > last_revno:
845
1003
raise errors.NoSuchRevision(self, revno)
846
return history[revno - 1]
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]
848
1009
@needs_write_lock
849
1010
def pull(self, source, overwrite=False, stop_revision=None,
867
1028
return InterBranch.get(self, target).push(overwrite, stop_revision,
868
1029
*args, **kwargs)
1031
def lossy_push(self, target, stop_revision=None):
1032
"""Push deltas into another branch.
1034
:note: This does not, like push, retain the revision ids from
1035
the source branch and will, rather than adding bzr-specific
1036
metadata, push only those semantics of the revision that can be
1037
natively represented by this branch' VCS.
1039
:param target: Target branch
1040
:param stop_revision: Revision to push, defaults to last revision.
1041
:return: BranchPushResult with an extra member revidmap:
1042
A dictionary mapping revision ids from the target branch
1043
to new revision ids in the target branch, for each
1044
revision that was pushed.
1046
inter = InterBranch.get(self, target)
1047
lossy_push = getattr(inter, "lossy_push", None)
1048
if lossy_push is None:
1049
raise errors.LossyPushToSameVCS(self, target)
1050
return lossy_push(stop_revision)
870
1052
def basis_tree(self):
871
1053
"""Return `Tree` object for last revision."""
872
1054
return self.repository.revision_tree(self.last_revision())
1064
1245
source_revno, source_revision_id = self.last_revision_info()
1065
1246
if revision_id is None:
1066
1247
revno, revision_id = source_revno, source_revision_id
1067
elif source_revision_id == revision_id:
1068
# we know the revno without needing to walk all of history
1069
revno = source_revno
1071
# To figure out the revno for a random revision, we need to build
1072
# the revision history, and count its length.
1073
# We don't care about the order, just how long it is.
1074
# Alternatively, we could start at the current location, and count
1075
# backwards. But there is no guarantee that we will find it since
1076
# it may be a merged revision.
1077
revno = len(list(self.repository.iter_reverse_revision_history(
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
1079
1256
destination.set_last_revision_info(revno, revision_id)
1081
1258
@needs_read_lock
1125
1302
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()
1127
1306
:return: A BranchCheckResult.
1129
mainline_parent_id = None
1308
result = BranchCheckResult(self)
1130
1309
last_revno, last_revision_id = self.last_revision_info()
1131
real_rev_history = list(self.repository.iter_reverse_revision_history(
1133
real_rev_history.reverse()
1134
if len(real_rev_history) != last_revno:
1135
raise errors.BzrCheckError('revno does not match len(mainline)'
1136
' %s != %s' % (last_revno, len(real_rev_history)))
1137
# TODO: We should probably also check that real_rev_history actually
1138
# matches self.revision_history()
1139
for revision_id in real_rev_history:
1141
revision = self.repository.get_revision(revision_id)
1142
except errors.NoSuchRevision, e:
1143
raise errors.BzrCheckError("mainline revision {%s} not in repository"
1145
# In general the first entry on the revision history has no parents.
1146
# But it's not illegal for it to have parents listed; this can happen
1147
# in imports from Arch when the parents weren't reachable.
1148
if mainline_parent_id is not None:
1149
if mainline_parent_id not in revision.parent_ids:
1150
raise errors.BzrCheckError("previous revision {%s} not listed among "
1152
% (mainline_parent_id, revision_id))
1153
mainline_parent_id = revision_id
1154
return BranchCheckResult(self)
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
1156
1322
def _get_checkout_format(self):
1157
1323
"""Return the most suitable metadir for a checkout of this branch.
1380
1554
"""Return the short format description for this format."""
1381
1555
raise NotImplementedError(self.get_format_description)
1383
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
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):
1385
1567
"""Initialize a branch in a bzrdir, with specified files
1387
1569
:param a_bzrdir: The bzrdir to initialize the branch in
1388
1570
:param utf8_files: The files to create as a list of
1389
1571
(filename, content) tuples
1572
:param name: Name of colocated branch to create, if any
1390
1573
:param set_format: If True, set the format with
1391
1574
self.get_format_string. (BzrBranch4 has its format set
1393
1576
:return: a branch in this format
1395
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1396
branch_transport = a_bzrdir.get_branch_transport(self)
1578
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1579
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1398
1581
'metadir': ('lock', lockdir.LockDir),
1399
1582
'branch4': ('branch-lock', lockable_files.TransportLock),
1572
1765
"multiple hooks installed for transform_fallback_location, "
1573
1766
"all are called with the url returned from the previous hook."
1574
1767
"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))
1577
1787
# install the default hooks into the Branch class.
1616
1826
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,
1619
1907
class BzrBranchFormat4(BranchFormat):
1620
1908
"""Bzr branch format 4.
1673
1962
return self.get_format_string()
1675
def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
1964
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1676
1965
"""See BranchFormat.open()."""
1678
format = BranchFormat.find_format(a_bzrdir)
1967
format = BranchFormat.find_format(a_bzrdir, name=name)
1679
1968
if format.__class__ != self.__class__:
1680
1969
raise AssertionError("wrong format %r found for %r" %
1681
1970
(format, self))
1971
transport = a_bzrdir.get_branch_transport(None, name=name)
1683
transport = a_bzrdir.get_branch_transport(None)
1684
1973
control_files = lockable_files.LockableFiles(transport, 'lock',
1685
1974
lockdir.LockDir)
1686
1975
return self._branch_class()(_format=self,
1687
1976
_control_files=control_files,
1688
1978
a_bzrdir=a_bzrdir,
1689
1979
_repository=a_bzrdir.find_repository(),
1690
1980
ignore_fallbacks=ignore_fallbacks)
1691
1981
except errors.NoSuchFile:
1692
raise errors.NotBranchError(path=transport.base)
1982
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1694
1984
def __init__(self):
1695
1985
super(BranchFormatMetadir, self).__init__()
1862
2160
def get_reference(self, a_bzrdir):
1863
2161
"""See BranchFormat.get_reference()."""
1864
2162
transport = a_bzrdir.get_branch_transport(None)
1865
return transport.get('location').read()
2163
return transport.get_bytes('location')
1867
2165
def set_reference(self, a_bzrdir, to_branch):
1868
2166
"""See BranchFormat.set_reference()."""
1869
2167
transport = a_bzrdir.get_branch_transport(None)
1870
2168
location = transport.put_bytes('location', to_branch.base)
1872
def initialize(self, a_bzrdir, target_branch=None):
2170
def initialize(self, a_bzrdir, name=None, target_branch=None):
1873
2171
"""Create a branch of this format in a_bzrdir."""
1874
2172
if target_branch is None:
1875
2173
# this format does not implement branch itself, thus the implicit
1876
2174
# creation contract must see it as uninitializable
1877
2175
raise errors.UninitializableFormat(self)
1878
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1879
branch_transport = a_bzrdir.get_branch_transport(self)
2176
mutter('creating branch reference in %s', a_bzrdir.user_url)
2177
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1880
2178
branch_transport.put_bytes('location',
1881
target_branch.bzrdir.root_transport.base)
2179
target_branch.bzrdir.user_url)
1882
2180
branch_transport.put_bytes('format', self.get_format_string())
1884
a_bzrdir, _found=True,
2182
a_bzrdir, name, _found=True,
1885
2183
possible_transports=[target_branch.bzrdir.root_transport])
2184
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1887
2187
def __init__(self):
1888
2188
super(BranchReferenceFormat, self).__init__()
1894
2194
def clone(to_bzrdir, revision_id=None,
1895
2195
repository_policy=None):
1896
2196
"""See Branch.clone()."""
1897
return format.initialize(to_bzrdir, a_branch)
2197
return format.initialize(to_bzrdir, target_branch=a_branch)
1898
2198
# cannot obey revision_id limits when cloning a reference ...
1899
2199
# FIXME RBC 20060210 either nuke revision_id for clone, or
1900
2200
# emit some sort of warning/error to the caller ?!
1903
def open(self, a_bzrdir, _found=False, location=None,
2203
def open(self, a_bzrdir, name=None, _found=False, location=None,
1904
2204
possible_transports=None, ignore_fallbacks=False):
1905
2205
"""Return the branch that the branch reference in a_bzrdir points at.
1907
2207
:param a_bzrdir: A BzrDir that contains a branch.
2208
:param name: Name of colocated branch to open, if any
1908
2209
:param _found: a private parameter, do not use it. It is used to
1909
2210
indicate if format probing has already be done.
1910
2211
:param ignore_fallbacks: when set, no fallback branches will be opened
1975
2277
:ivar repository: Repository for this branch.
1976
2278
:ivar base: The url of the base directory for this branch; the one
1977
2279
containing the .bzr directory.
2280
:ivar name: Optional colocated branch name as it exists in the control
1980
2284
def __init__(self, _format=None,
1981
_control_files=None, a_bzrdir=None, _repository=None,
1982
ignore_fallbacks=False):
2285
_control_files=None, a_bzrdir=None, name=None,
2286
_repository=None, ignore_fallbacks=False):
1983
2287
"""Create new branch object at a particular location."""
1984
2288
if a_bzrdir is None:
1985
2289
raise ValueError('a_bzrdir must be supplied')
1987
2291
self.bzrdir = a_bzrdir
1988
2292
self._base = self.bzrdir.transport.clone('..').base
1989
2294
# XXX: We should be able to just do
1990
2295
# self.base = self.bzrdir.root_transport.base
1991
2296
# but this does not quite work yet -- mbp 20080522
2345
2661
raise AssertionError(
2346
2662
"'transform_fallback_location' hook %s returned "
2347
2663
"None, not a URL." % hook_name)
2348
self._activate_fallback_location(url, None)
2664
self._activate_fallback_location(url)
2350
2666
def __init__(self, *args, **kwargs):
2351
2667
self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2352
2668
super(BzrBranch8, self).__init__(*args, **kwargs)
2353
2669
self._last_revision_info_cache = None
2354
self._partial_revision_history_cache = []
2355
2670
self._reference_info = None
2357
2672
def _clear_cached_state(self):
2358
2673
super(BzrBranch8, self)._clear_cached_state()
2359
2674
self._last_revision_info_cache = None
2360
self._partial_revision_history_cache = []
2361
2675
self._reference_info = None
2363
2677
def _last_revision_info(self):
2419
2733
self._extend_partial_history(stop_index=last_revno-1)
2420
2734
return list(reversed(self._partial_revision_history_cache))
2422
def _extend_partial_history(self, stop_index=None, stop_revision=None):
2423
"""Extend the partial history to include a given index
2425
If a stop_index is supplied, stop when that index has been reached.
2426
If a stop_revision is supplied, stop when that revision is
2427
encountered. Otherwise, stop when the beginning of history is
2430
:param stop_index: The index which should be present. When it is
2431
present, history extension will stop.
2432
:param revision_id: The revision id which should be present. When
2433
it is encountered, history extension will stop.
2435
repo = self.repository
2436
if len(self._partial_revision_history_cache) == 0:
2437
iterator = repo.iter_reverse_revision_history(self.last_revision())
2439
start_revision = self._partial_revision_history_cache[-1]
2440
iterator = repo.iter_reverse_revision_history(start_revision)
2441
#skip the last revision in the list
2442
next_revision = iterator.next()
2443
for revision_id in iterator:
2444
self._partial_revision_history_cache.append(revision_id)
2445
if (stop_index is not None and
2446
len(self._partial_revision_history_cache) > stop_index):
2448
if revision_id == stop_revision:
2451
2736
def _write_revision_history(self, history):
2452
2737
"""Factored out of set_revision_history.