/brz/remove-bazaar : contents of bzrlib/memorytree.py at revision 4210.4.1

: (revision 4210.4.1)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

# Copyright (C) 2006 Canonical Ltd
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""MemoryTree object.

See MemoryTree for more details.
"""


from copy import deepcopy
import os

from bzrlib import (
    errors,
    mutabletree,
    osutils,
    revision as _mod_revision,
    )
from bzrlib.decorators import needs_read_lock, needs_write_lock
from bzrlib.osutils import sha_file
from bzrlib.mutabletree import needs_tree_write_lock
from bzrlib.transport.memory import MemoryTransport


class MemoryTree(mutabletree.MutableTree):
    """A MemoryTree is a specialisation of MutableTree.

    It maintains nearly no state outside of read_lock and write_lock
    transactions. (it keeps a reference to the branch, and its last-revision
    only).
    """

    def __init__(self, branch, revision_id):
        """Construct a MemoryTree for branch using revision_id."""
        self.branch = branch
        self.bzrdir = branch.bzrdir
        self._branch_revision_id = revision_id
        self._locks = 0
        self._lock_mode = None

    @needs_tree_write_lock
    def _add(self, files, ids, kinds):
        """See MutableTree._add."""
        for f, file_id, kind in zip(files, ids, kinds):
            if kind is None:
                kind = 'file'
            if file_id is None:
                self._inventory.add_path(f, kind=kind)
            else:
                self._inventory.add_path(f, kind=kind, file_id=file_id)

    def basis_tree(self):
        """See Tree.basis_tree()."""
        return self._basis_tree

    @staticmethod
    def create_on_branch(branch):
        """Create a MemoryTree for branch, using the last-revision of branch."""
        revision_id = _mod_revision.ensure_null(branch.last_revision())
        return MemoryTree(branch, revision_id)

    def _gather_kinds(self, files, kinds):
        """See MutableTree._gather_kinds.

        This implementation does not care about the file kind of
        missing files, so is a no-op.
        """

    def get_file(self, file_id, path=None):
        """See Tree.get_file."""
        if path is None:
            path = self.id2path(file_id)
        return self._file_transport.get(path)

    def get_file_sha1(self, file_id, path=None, stat_value=None):
        """See Tree.get_file_sha1()."""
        if path is None:
            path = self.id2path(file_id)
        stream = self._file_transport.get(path)
        return sha_file(stream)

    def get_root_id(self):
        return self.path2id('')

    def _comparison_data(self, entry, path):
        """See Tree._comparison_data."""
        if entry is None:
            return None, False, None
        return entry.kind, entry.executable, None

    @needs_tree_write_lock
    def rename_one(self, from_rel, to_rel):
        file_id = self.path2id(from_rel)
        to_dir, to_tail = os.path.split(to_rel)
        to_parent_id = self.path2id(to_dir)
        self._file_transport.move(from_rel, to_rel)
        self._inventory.rename(file_id, to_parent_id, to_tail)

    def path_content_summary(self, path):
        """See Tree.path_content_summary."""
        id = self.path2id(path)
        if id is None:
            return 'missing', None, None, None
        kind = self.kind(id)
        if kind == 'file':
            bytes = self._file_transport.get_bytes(path)
            size = len(bytes)
            executable = self._inventory[id].executable
            sha1 = None # no stat cache
            return (kind, size, executable, sha1)
        elif kind == 'directory':
            # memory tree does not support nested trees yet.
            return kind, None, None, None
        elif kind == 'symlink':
            raise NotImplementedError('symlink support')
        else:
            raise NotImplementedError('unknown kind')

    def _file_size(self, entry, stat_value):
        """See Tree._file_size."""
        if entry is None:
            return 0
        return entry.text_size

    @needs_read_lock
    def get_parent_ids(self):
        """See Tree.get_parent_ids.

        This implementation returns the current cached value from
            self._parent_ids.
        """
        return list(self._parent_ids)

    def has_filename(self, filename):
        """See Tree.has_filename()."""
        return self._file_transport.has(filename)

    def is_executable(self, file_id, path=None):
        return self._inventory[file_id].executable

    def kind(self, file_id):
        return self._inventory[file_id].kind

    def mkdir(self, path, file_id=None):
        """See MutableTree.mkdir()."""
        self.add(path, file_id, 'directory')
        if file_id is None:
            file_id = self.path2id(path)
        self._file_transport.mkdir(path)
        return file_id

    @needs_read_lock
    def last_revision(self):
        """See MutableTree.last_revision."""
        return self._branch_revision_id

    def lock_read(self):
        """Lock the memory tree for reading.

        This triggers population of data from the branch for its revision.
        """
        self._locks += 1
        try:
            if self._locks == 1:
                self.branch.lock_read()
                self._lock_mode = "r"
                self._populate_from_branch()
        except:
            self._locks -= 1
            raise

    def lock_tree_write(self):
        """See MutableTree.lock_tree_write()."""
        self._locks += 1
        try:
            if self._locks == 1:
                self.branch.lock_read()
                self._lock_mode = "w"
                self._populate_from_branch()
            elif self._lock_mode == "r":
                raise errors.ReadOnlyError(self)
        except:
            self._locks -= 1
            raise

    def lock_write(self):
        """See MutableTree.lock_write()."""
        self._locks += 1
        try:
            if self._locks == 1:
                self.branch.lock_write()
                self._lock_mode = "w"
                self._populate_from_branch()
            elif self._lock_mode == "r":
                raise errors.ReadOnlyError(self)
        except:
            self._locks -= 1
            raise

    def _populate_from_branch(self):
        """Populate the in-tree state from the branch."""
        self._set_basis()
        if self._branch_revision_id == _mod_revision.NULL_REVISION:
            self._parent_ids = []
        else:
            self._parent_ids = [self._branch_revision_id]
        self._inventory = deepcopy(self._basis_tree._inventory)
        self._file_transport = MemoryTransport()
        # TODO copy the revision trees content, or do it lazy, or something.
        inventory_entries = self._inventory.iter_entries()
        for path, entry in inventory_entries:
            if path == '':
                continue
            if entry.kind == 'directory':
                self._file_transport.mkdir(path)
            elif entry.kind == 'file':
                self._file_transport.put_file(path,
                    self._basis_tree.get_file(entry.file_id))
            else:
                raise NotImplementedError(self._populate_from_branch)

    def put_file_bytes_non_atomic(self, file_id, bytes):
        """See MutableTree.put_file_bytes_non_atomic."""
        self._file_transport.put_bytes(self.id2path(file_id), bytes)

    def unlock(self):
        """Release a lock.

        This frees all cached state when the last lock context for the tree is
        left.
        """
        if self._locks == 1:
            self._basis_tree = None
            self._parent_ids = []
            self._inventory = None
            try:
                self.branch.unlock()
            finally:
                self._locks = 0
                self._lock_mode = None
        else:
            self._locks -= 1

    @needs_tree_write_lock
    def unversion(self, file_ids):
        """Remove the file ids in file_ids from the current versioned set.

        When a file_id is unversioned, all of its children are automatically
        unversioned.

        :param file_ids: The file ids to stop versioning.
        :raises: NoSuchId if any fileid is not currently versioned.
        """
        # XXX: This should be in mutabletree, but the inventory-save action
        # is not relevant to memory tree. Until that is done in unlock by
        # working tree, we cannot share the implementation.
        for file_id in file_ids:
            if self._inventory.has_id(file_id):
                self._inventory.remove_recursive_id(file_id)
            else:
                raise errors.NoSuchId(self, file_id)

    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
        """See MutableTree.set_parent_trees()."""
        for revision_id in revision_ids:
            _mod_revision.check_not_reserved_id(revision_id)
        if len(revision_ids) == 0:
            self._parent_ids = []
            self._branch_revision_id = _mod_revision.NULL_REVISION
        else:
            self._parent_ids = revision_ids
            self._branch_revision_id = revision_ids[0]
        self._allow_leftmost_as_ghost = allow_leftmost_as_ghost
        self._set_basis()
    
    def _set_basis(self):
        try:
            self._basis_tree = self.branch.repository.revision_tree(
                self._branch_revision_id)
        except errors.NoSuchRevision:
            if self._allow_leftmost_as_ghost:
                self._basis_tree = self.branch.repository.revision_tree(
                    _mod_revision.NULL_REVISION)
            else:
                raise

    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
        """See MutableTree.set_parent_trees()."""
        if len(parents_list) == 0:
            self._parent_ids = []
            self._basis_tree = self.branch.repository.revision_tree(
                                   _mod_revision.NULL_REVISION)
        else:
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
                # a ghost in the left most parent
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
                self._basis_tree = self.branch.repository.revision_tree(
                                       _mod_revision.NULL_REVISION)
            else:
                self._basis_tree = parents_list[0][1]
            self._branch_revision_id = parents_list[0][0]

1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	1	# Copyright (C) 2006 Canonical Ltd
	2	#
	3	# This program is free software; you can redistribute it and/or modify
	4	# it under the terms of the GNU General Public License as published by
	5	# the Free Software Foundation; either version 2 of the License, or
	6	# (at your option) any later version.
	7	#
	8	# This program is distributed in the hope that it will be useful,
	9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	# GNU General Public License for more details.
	12	#
	13	# You should have received a copy of the GNU General Public License
	14	# along with this program; if not, write to the Free Software
4183.7.1 by Sabin Iacob update FSF mailing address	15	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	16
	17	"""MemoryTree object.
	18
	19	See MemoryTree for more details.
	20	"""
	21
	22
	23	from copy import deepcopy
3567.5.1 by John Arbash Meinel Implement rename_one on MemoryTree, and expose that in the Branch Builder	24	import os
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	25
2598.5.1 by Aaron Bentley Start eliminating the use of None to indicate null revision	26	from bzrlib import (
	27	errors,
	28	mutabletree,
3567.5.1 by John Arbash Meinel Implement rename_one on MemoryTree, and expose that in the Branch Builder	29	osutils,
2598.5.1 by Aaron Bentley Start eliminating the use of None to indicate null revision	30	revision as _mod_revision,
	31	)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	32	from bzrlib.decorators import needs_read_lock, needs_write_lock
	33	from bzrlib.osutils import sha_file
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	34	from bzrlib.mutabletree import needs_tree_write_lock
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	35	from bzrlib.transport.memory import MemoryTransport
	36
	37
	38	class MemoryTree(mutabletree.MutableTree):
	39	"""A MemoryTree is a specialisation of MutableTree.
3943.8.1 by Marius Kruger remove all trailing whitespace from bzr source	40
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	41	It maintains nearly no state outside of read_lock and write_lock
	42	transactions. (it keeps a reference to the branch, and its last-revision
	43	only).
	44	"""
	45
	46	def __init__(self, branch, revision_id):
	47	"""Construct a MemoryTree for branch using revision_id."""
	48	self.branch = branch
	49	self.bzrdir = branch.bzrdir
	50	self._branch_revision_id = revision_id
	51	self._locks = 0
	52	self._lock_mode = None
	53
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	54	@needs_tree_write_lock
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	55	def _add(self, files, ids, kinds):
	56	"""See MutableTree._add."""
	57	for f, file_id, kind in zip(files, ids, kinds):
	58	if kind is None:
	59	kind = 'file'
	60	if file_id is None:
	61	self._inventory.add_path(f, kind=kind)
	62	else:
	63	self._inventory.add_path(f, kind=kind, file_id=file_id)
	64
	65	def basis_tree(self):
	66	"""See Tree.basis_tree()."""
	67	return self._basis_tree
	68
	69	@staticmethod
	70	def create_on_branch(branch):
	71	"""Create a MemoryTree for branch, using the last-revision of branch."""
2598.5.4 by Aaron Bentley Restore original Branch.last_revision behavior, fix bits that care	72	revision_id = _mod_revision.ensure_null(branch.last_revision())
2598.5.1 by Aaron Bentley Start eliminating the use of None to indicate null revision	73	return MemoryTree(branch, revision_id)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	74
	75	def _gather_kinds(self, files, kinds):
	76	"""See MutableTree._gather_kinds.
3943.8.1 by Marius Kruger remove all trailing whitespace from bzr source	77
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	78	This implementation does not care about the file kind of
	79	missing files, so is a no-op.
	80	"""
	81
2743.3.3 by Ian Clatworthy Skip path lookup for tree.get_file() when we already know the path	82	def get_file(self, file_id, path=None):
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	83	"""See Tree.get_file."""
2743.3.3 by Ian Clatworthy Skip path lookup for tree.get_file() when we already know the path	84	if path is None:
	85	path = self.id2path(file_id)
	86	return self._file_transport.get(path)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	87
2564.2.1 by Ian Clatworthy refactor commit to support alternative population meothds	88	def get_file_sha1(self, file_id, path=None, stat_value=None):
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	89	"""See Tree.get_file_sha1()."""
	90	if path is None:
	91	path = self.id2path(file_id)
	92	stream = self._file_transport.get(path)
	93	return sha_file(stream)
	94
2946.3.5 by John Arbash Meinel MemoryTree is not tested under the tree_implementations tests.	95	def get_root_id(self):
	96	return self.path2id('')
	97
2564.2.1 by Ian Clatworthy refactor commit to support alternative population meothds	98	def _comparison_data(self, entry, path):
	99	"""See Tree._comparison_data."""
	100	if entry is None:
	101	return None, False, None
	102	return entry.kind, entry.executable, None
	103
3567.5.1 by John Arbash Meinel Implement rename_one on MemoryTree, and expose that in the Branch Builder	104	@needs_tree_write_lock
	105	def rename_one(self, from_rel, to_rel):
	106	file_id = self.path2id(from_rel)
	107	to_dir, to_tail = os.path.split(to_rel)
3514.4.44 by John Arbash Meinel Revert the path2id fix, because to_dir can be anywhere, not just	108	to_parent_id = self.path2id(to_dir)
3567.5.1 by John Arbash Meinel Implement rename_one on MemoryTree, and expose that in the Branch Builder	109	self._file_transport.move(from_rel, to_rel)
	110	self._inventory.rename(file_id, to_parent_id, to_tail)
3514.4.38 by John Arbash Meinel Use direct access to the inventory instead of path2id.	111
2776.4.2 by Robert Collins nuke _read_tree_state and snapshot from inventory, moving responsibility into the commit builder.	112	def path_content_summary(self, path):
	113	"""See Tree.path_content_summary."""
	114	id = self.path2id(path)
	115	if id is None:
	116	return 'missing', None, None, None
	117	kind = self.kind(id)
	118	if kind == 'file':
	119	bytes = self._file_transport.get_bytes(path)
	120	size = len(bytes)
	121	executable = self._inventory[id].executable
	122	sha1 = None # no stat cache
	123	return (kind, size, executable, sha1)
	124	elif kind == 'directory':
	125	# memory tree does not support nested trees yet.
	126	return kind, None, None, None
	127	elif kind == 'symlink':
	128	raise NotImplementedError('symlink support')
	129	else:
	130	raise NotImplementedError('unknown kind')
	131
2564.2.1 by Ian Clatworthy refactor commit to support alternative population meothds	132	def _file_size(self, entry, stat_value):
	133	"""See Tree._file_size."""
	134	if entry is None:
	135	return 0
	136	return entry.text_size
	137
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	138	@needs_read_lock
	139	def get_parent_ids(self):
	140	"""See Tree.get_parent_ids.
	141
	142	This implementation returns the current cached value from
	143	self._parent_ids.
	144	"""
	145	return list(self._parent_ids)
	146
	147	def has_filename(self, filename):
	148	"""See Tree.has_filename()."""
	149	return self._file_transport.has(filename)
	150
	151	def is_executable(self, file_id, path=None):
	152	return self._inventory[file_id].executable
	153
1959.4.2 by Aaron Bentley Merge bzr.dev	154	def kind(self, file_id):
	155	return self._inventory[file_id].kind
	156
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	157	def mkdir(self, path, file_id=None):
	158	"""See MutableTree.mkdir()."""
	159	self.add(path, file_id, 'directory')
	160	if file_id is None:
	161	file_id = self.path2id(path)
	162	self._file_transport.mkdir(path)
	163	return file_id
	164
1986.1.6 by Robert Collins Add MemoryTree.last_revision.	165	@needs_read_lock
	166	def last_revision(self):
	167	"""See MutableTree.last_revision."""
	168	return self._branch_revision_id
	169
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	170	def lock_read(self):
	171	"""Lock the memory tree for reading.
	172
	173	This triggers population of data from the branch for its revision.
	174	"""
	175	self._locks += 1
	176	try:
	177	if self._locks == 1:
	178	self.branch.lock_read()
	179	self._lock_mode = "r"
	180	self._populate_from_branch()
	181	except:
	182	self._locks -= 1
	183	raise
	184
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	185	def lock_tree_write(self):
	186	"""See MutableTree.lock_tree_write()."""
	187	self._locks += 1
	188	try:
	189	if self._locks == 1:
	190	self.branch.lock_read()
	191	self._lock_mode = "w"
	192	self._populate_from_branch()
	193	elif self._lock_mode == "r":
	194	raise errors.ReadOnlyError(self)
	195	except:
	196	self._locks -= 1
	197	raise
	198
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	199	def lock_write(self):
	200	"""See MutableTree.lock_write()."""
	201	self._locks += 1
	202	try:
	203	if self._locks == 1:
	204	self.branch.lock_write()
	205	self._lock_mode = "w"
	206	self._populate_from_branch()
	207	elif self._lock_mode == "r":
	208	raise errors.ReadOnlyError(self)
	209	except:
	210	self._locks -= 1
	211	raise
	212
	213	def _populate_from_branch(self):
	214	"""Populate the in-tree state from the branch."""
4190.1.4 by Robert Collins Cache ghosts when we can get them from a RemoteRepository in get_parent_map.	215	self._set_basis()
3668.5.4 by Jelmer Vernooij Eliminate more uses of Repository.revision_tree(None).	216	if self._branch_revision_id == _mod_revision.NULL_REVISION:
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	217	self._parent_ids = []
	218	else:
	219	self._parent_ids = [self._branch_revision_id]
	220	self._inventory = deepcopy(self._basis_tree._inventory)
	221	self._file_transport = MemoryTransport()
	222	# TODO copy the revision trees content, or do it lazy, or something.
	223	inventory_entries = self._inventory.iter_entries()
	224	for path, entry in inventory_entries:
1731.1.50 by Aaron Bentley Merge bzr.dev	225	if path == '':
1731.1.50 by Aaron Bentley Merge bzr.dev	226	continue
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	227	if entry.kind == 'directory':
	228	self._file_transport.mkdir(path)
	229	elif entry.kind == 'file':
1986.1.4 by Robert Collins Fixup deprecations from bzr.dev.	230	self._file_transport.put_file(path,
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	231	self._basis_tree.get_file(entry.file_id))
	232	else:
	233	raise NotImplementedError(self._populate_from_branch)
	234
	235	def put_file_bytes_non_atomic(self, file_id, bytes):
	236	"""See MutableTree.put_file_bytes_non_atomic."""
1986.1.4 by Robert Collins Fixup deprecations from bzr.dev.	237	self._file_transport.put_bytes(self.id2path(file_id), bytes)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	238
	239	def unlock(self):
	240	"""Release a lock.
	241
	242	This frees all cached state when the last lock context for the tree is
	243	left.
	244	"""
	245	if self._locks == 1:
	246	self._basis_tree = None
	247	self._parent_ids = []
	248	self._inventory = None
	249	try:
	250	self.branch.unlock()
	251	finally:
	252	self._locks = 0
	253	self._lock_mode = None
	254	else:
	255	self._locks -= 1
	256
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	257	@needs_tree_write_lock
1986.1.3 by Robert Collins Merge bzr.dev.	258	def unversion(self, file_ids):
	259	"""Remove the file ids in file_ids from the current versioned set.
	260
	261	When a file_id is unversioned, all of its children are automatically
	262	unversioned.
	263
	264	:param file_ids: The file ids to stop versioning.
	265	:raises: NoSuchId if any fileid is not currently versioned.
	266	"""
	267	# XXX: This should be in mutabletree, but the inventory-save action
	268	# is not relevant to memory tree. Until that is done in unlock by
	269	# working tree, we cannot share the implementation.
	270	for file_id in file_ids:
	271	if self._inventory.has_id(file_id):
	272	self._inventory.remove_recursive_id(file_id)
	273	else:
	274	raise errors.NoSuchId(self, file_id)
	275
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	276	def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
	277	"""See MutableTree.set_parent_trees()."""
2598.5.2 by Aaron Bentley Got all tests passing with Branch returning 'null:' for null revision	278	for revision_id in revision_ids:
	279	_mod_revision.check_not_reserved_id(revision_id)
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	280	if len(revision_ids) == 0:
	281	self._parent_ids = []
4190.1.4 by Robert Collins Cache ghosts when we can get them from a RemoteRepository in get_parent_map.	282	self._branch_revision_id = _mod_revision.NULL_REVISION
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	283	else:
	284	self._parent_ids = revision_ids
	285	self._branch_revision_id = revision_ids[0]
4190.1.4 by Robert Collins Cache ghosts when we can get them from a RemoteRepository in get_parent_map.	286	self._allow_leftmost_as_ghost = allow_leftmost_as_ghost
	287	self._set_basis()
	288
	289	def _set_basis(self):
	290	try:
	291	self._basis_tree = self.branch.repository.revision_tree(
	292	self._branch_revision_id)
	293	except errors.NoSuchRevision:
	294	if self._allow_leftmost_as_ghost:
	295	self._basis_tree = self.branch.repository.revision_tree(
	296	_mod_revision.NULL_REVISION)
	297	else:
	298	raise
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	299
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	300	def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
	301	"""See MutableTree.set_parent_trees()."""
	302	if len(parents_list) == 0:
	303	self._parent_ids = []
3668.5.1 by Jelmer Vernooij Use NULL_REVISION rather than None for Repository.revision_tree().	304	self._basis_tree = self.branch.repository.revision_tree(
	305	_mod_revision.NULL_REVISION)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	306	else:
	307	if parents_list[0][1] is None and not allow_leftmost_as_ghost:
	308	# a ghost in the left most parent
	309	raise errors.GhostRevisionUnusableHere(parents_list[0][0])
	310	self._parent_ids = [parent_id for parent_id, tree in parents_list]
2598.5.2 by Aaron Bentley Got all tests passing with Branch returning 'null:' for null revision	311	if parents_list[0][1] is None or parents_list[0][1] == 'null:':
3668.5.1 by Jelmer Vernooij Use NULL_REVISION rather than None for Repository.revision_tree().	312	self._basis_tree = self.branch.repository.revision_tree(
	313	_mod_revision.NULL_REVISION)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	314	else:
	315	self._basis_tree = parents_list[0][1]
1986.1.6 by Robert Collins Add MemoryTree.last_revision.	316	self._branch_revision_id = parents_list[0][0]