def test_tree_reference(self): s_v5 = bzrlib.xml5.serializer_v5 s_v6 = bzrlib.xml6.serializer_v6 s_v7 = xml7.serializer_v7 inv = Inventory('tree-root-321', revision_id='rev-outer') inv.root.revision = 'root-rev' inv.add( inventory.TreeReference('nested-id', 'nested', 'tree-root-321', 'rev-outer', 'rev-inner')) self.assertRaises(errors.UnsupportedInventoryKind, s_v5.write_inventory_to_string, inv) self.assertRaises(errors.UnsupportedInventoryKind, s_v6.write_inventory_to_string, inv) txt = s_v7.write_inventory_to_string(inv) lines = s_v7.write_inventory_to_lines(inv) self.assertEqual(bzrlib.osutils.split_lines(txt), lines) inv2 = s_v7.read_inventory_from_string(txt) self.assertEqual('tree-root-321', inv2['nested-id'].parent_id) self.assertEqual('rev-outer', inv2['nested-id'].revision) self.assertEqual('rev-inner', inv2['nested-id'].reference_revision) self.assertRaises(errors.UnsupportedInventoryKind, s_v6.read_inventory_from_string, txt.replace('format="7"', 'format="6"')) self.assertRaises(errors.UnsupportedInventoryKind, s_v5.read_inventory_from_string, txt.replace('format="7"', 'format="5"'))
def test_tree_reference(self): s_v5 = bzrlib.xml5.serializer_v5 s_v6 = bzrlib.xml6.serializer_v6 s_v7 = xml7.serializer_v7 inv = Inventory('tree-root-321', revision_id='rev-outer') inv.root.revision = 'root-rev' inv.add(inventory.TreeReference('nested-id', 'nested', 'tree-root-321', 'rev-outer', 'rev-inner')) self.assertRaises(errors.UnsupportedInventoryKind, s_v5.write_inventory_to_string, inv) self.assertRaises(errors.UnsupportedInventoryKind, s_v6.write_inventory_to_string, inv) txt = s_v7.write_inventory_to_string(inv) lines = s_v7.write_inventory_to_lines(inv) self.assertEqual(bzrlib.osutils.split_lines(txt), lines) inv2 = s_v7.read_inventory_from_string(txt) self.assertEqual('tree-root-321', inv2['nested-id'].parent_id) self.assertEqual('rev-outer', inv2['nested-id'].revision) self.assertEqual('rev-inner', inv2['nested-id'].reference_revision) self.assertRaises(errors.UnsupportedInventoryKind, s_v6.read_inventory_from_string, txt.replace('format="7"', 'format="6"')) self.assertRaises(errors.UnsupportedInventoryKind, s_v5.read_inventory_from_string, txt.replace('format="7"', 'format="5"'))
def test_richroot_unversioned_root_errors(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') new_inv.add(root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=True) err = self.assertRaises(InventoryDeltaError, serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta) self.assertEqual(str(err), 'no version for fileid TREE_ROOT')
def test_root_only_to_lines(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'an-id') root.revision = 'a@e\xc3\xa5ample.com--2004' new_inv.add(root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=True) self.assertEqual(StringIO(root_only_lines).readlines(), serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
def test_nonrichroot_versioned_root_errors(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') root.revision = 'a@e\xc3\xa5ample.com--2004' new_inv.add(root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=False, tree_references=True) err = self.assertRaises(InventoryDeltaError, serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta) self.assertStartsWith(str(err), 'Version present for / in TREE_ROOT')
def test_root_only_to_lines(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'an-id') root.revision = 'a@e\xc3\xa5ample.com--2004' new_inv.add(root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=True) self.assertEqual( StringIO(root_only_lines).readlines(), serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
def _unpack_inventory(self, elt, revision_id=None): """Construct from XML Element :param revision_id: Ignored parameter used by xml5. """ root_id = elt.get('file_id') or ROOT_ID inv = Inventory(root_id) for e in elt: ie = self._unpack_entry(e) if ie.parent_id == ROOT_ID: ie.parent_id = root_id inv.add(ie) return inv
def test_unversioned_non_root_errors(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') root.revision = 'a@e\xc3\xa5ample.com--2004' new_inv.add(root) non_root = new_inv.make_entry('directory', 'foo', root.file_id, 'id') new_inv.add(non_root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=True) err = self.assertRaises(InventoryDeltaError, serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta) self.assertEqual(str(err), 'no version for fileid id')
def test_tree_reference_enabled(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') root.revision = 'a@e\xc3\xa5ample.com--2004' new_inv.add(root) non_root = new_inv.make_entry( 'tree-reference', 'foo', root.file_id, 'id') non_root.revision = 'changed' non_root.reference_revision = 'subtree-version' new_inv.add(non_root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=True) self.assertEqual(StringIO(reference_lines).readlines(), serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
def test_tree_reference_enabled(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') root.revision = 'a@e\xc3\xa5ample.com--2004' new_inv.add(root) non_root = new_inv.make_entry('tree-reference', 'foo', root.file_id, 'id') non_root.revision = 'changed' non_root.reference_revision = 'subtree-version' new_inv.add(non_root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=True) self.assertEqual( StringIO(reference_lines).readlines(), serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
def test_unversioned_root(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') # Implicit roots are considered modified in every revision. root.revision = 'entry-version' new_inv.add(root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=False, tree_references=False) serialized_lines = serializer.delta_to_lines( NULL_REVISION, 'entry-version', delta) self.assertEqual(StringIO(root_only_unversioned).readlines(), serialized_lines) deserializer = inventory_delta.InventoryDeltaDeserializer() self.assertEqual( (NULL_REVISION, 'entry-version', False, False, delta), deserializer.parse_text_bytes(''.join(serialized_lines)))
def test_unversioned_root(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') # Implicit roots are considered modified in every revision. root.revision = 'entry-version' new_inv.add(root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=False, tree_references=False) serialized_lines = serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta) self.assertEqual( StringIO(root_only_unversioned).readlines(), serialized_lines) deserializer = inventory_delta.InventoryDeltaDeserializer() self.assertEqual( (NULL_REVISION, 'entry-version', False, False, delta), deserializer.parse_text_bytes(''.join(serialized_lines)))
def read_inventory(inv_file): """Read inventory object from rio formatted inventory file""" from bzrlib.inventory import Inventory, InventoryFile s = read_stanza(inv_file) assert s['inventory_version'] == 7 inv = Inventory() for s in read_stanzas(inv_file): kind, file_id = s.items[0] parent_id = None if 'parent_id' in s: parent_id = s['parent_id'] if kind == 'file': ie = InventoryFile(file_id, s['name'], parent_id) ie.text_sha1 = s['text_sha1'] ie.text_size = s['text_size'] else: raise NotImplementedError() inv.add(ie) return inv
def test_tree_reference_disabled(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') root.revision = 'a@e\xc3\xa5ample.com--2004' new_inv.add(root) non_root = new_inv.make_entry( 'tree-reference', 'foo', root.file_id, 'id') non_root.revision = 'changed' non_root.reference_revision = 'subtree-version' new_inv.add(non_root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=False) # we expect keyerror because there is little value wrapping this. # This test aims to prove that it errors more than how it errors. err = self.assertRaises(KeyError, serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta) self.assertEqual(('tree-reference',), err.args)
def test_unknown_kind_errors(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'my-rich-root-id') root.revision = 'changed' new_inv.add(root) class StrangeInventoryEntry(inventory.InventoryEntry): kind = 'strange' non_root = StrangeInventoryEntry('id', 'foo', root.file_id) non_root.revision = 'changed' new_inv.add(non_root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=True) # we expect keyerror because there is little value wrapping this. # This test aims to prove that it errors more than how it errors. err = self.assertRaises(KeyError, serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta) self.assertEqual(('strange',), err.args)
def test_tree_reference_disabled(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'TREE_ROOT') root.revision = 'a@e\xc3\xa5ample.com--2004' new_inv.add(root) non_root = new_inv.make_entry('tree-reference', 'foo', root.file_id, 'id') non_root.revision = 'changed' non_root.reference_revision = 'subtree-version' new_inv.add(non_root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=False) # we expect keyerror because there is little value wrapping this. # This test aims to prove that it errors more than how it errors. err = self.assertRaises(KeyError, serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta) self.assertEqual(('tree-reference', ), err.args)
def test_unknown_kind_errors(self): old_inv = Inventory(None) new_inv = Inventory(None) root = new_inv.make_entry('directory', '', None, 'my-rich-root-id') root.revision = 'changed' new_inv.add(root) class StrangeInventoryEntry(inventory.InventoryEntry): kind = 'strange' non_root = StrangeInventoryEntry('id', 'foo', root.file_id) non_root.revision = 'changed' new_inv.add(non_root) delta = new_inv._make_delta(old_inv) serializer = inventory_delta.InventoryDeltaSerializer( versioned_root=True, tree_references=True) # we expect keyerror because there is little value wrapping this. # This test aims to prove that it errors more than how it errors. err = self.assertRaises(KeyError, serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta) self.assertEqual(('strange', ), err.args)
def make_one_file_inventory(self, repo, revision, parents, inv_revision=None, root_revision=None, file_contents=None, make_file_version=True): """Make an inventory containing a version of a file with ID 'a-file'. The file's ID will be 'a-file', and its filename will be 'a file name', stored at the tree root. :param repo: a repository to add the new file version to. :param revision: the revision ID of the new inventory. :param parents: the parents for this revision of 'a-file'. :param inv_revision: if not None, the revision ID to store in the inventory entry. Otherwise, this defaults to revision. :param root_revision: if not None, the inventory's root.revision will be set to this. :param file_contents: if not None, the contents of this file version. Otherwise a unique default (based on revision ID) will be generated. """ inv = Inventory(revision_id=revision) if root_revision is not None: inv.root.revision = root_revision file_id = 'a-file-id' entry = InventoryFile(file_id, 'a file name', 'TREE_ROOT') if inv_revision is not None: entry.revision = inv_revision else: entry.revision = revision entry.text_size = 0 if file_contents is None: file_contents = '%sline\n' % entry.revision entry.text_sha1 = osutils.sha_string(file_contents) inv.add(entry) if make_file_version: repo.texts.add_lines((file_id, revision), [(file_id, parent) for parent in parents], [file_contents]) return inv
def get_sample_inventory(self): inv = Inventory('tree-root-321', revision_id='rev_outer') inv.add(inventory.InventoryFile('file-id', 'file', 'tree-root-321')) inv.add(inventory.InventoryDirectory('dir-id', 'dir', 'tree-root-321')) inv.add(inventory.InventoryLink('link-id', 'link', 'tree-root-321')) inv['tree-root-321'].revision = 'rev_outer' inv['dir-id'].revision = 'rev_outer' inv['file-id'].revision = 'rev_outer' inv['file-id'].text_sha1 = 'A' inv['file-id'].text_size = 1 inv['link-id'].revision = 'rev_outer' inv['link-id'].symlink_target = 'a' return inv
class MemoryTree(mutabletree.MutableInventoryTree): """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 def get_config_stack(self): return self.branch.get_config_stack() def is_control_filename(self, filename): # Memory tree doesn't have any control filenames return False @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 = Inventory(None, self._basis_tree.get_revision_id()) self._file_transport = MemoryTransport() # TODO copy the revision trees content, or do it lazy, or something. inventory_entries = self._basis_tree.iter_entries_by_dir() for path, entry in inventory_entries: self._inventory.add(entry.copy()) 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]
class MemoryTree(mutabletree.MutableInventoryTree): """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 def get_config_stack(self): return self.branch.get_config_stack() def is_control_filename(self, filename): # Memory tree doesn't have any control filenames return False @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 = Inventory(None, self._basis_tree.get_revision_id()) self._file_transport = MemoryTransport() # TODO copy the revision trees content, or do it lazy, or something. inventory_entries = self._basis_tree.iter_entries_by_dir() for path, entry in inventory_entries: self._inventory.add(entry.copy()) 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]