~bzr-pqm/bzr/bzr.dev

#

# 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

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

 

"""WorkingTree object and friends.

 

A WorkingTree represents the editable working copy of a branch.

new revision based on the workingtree and its inventory.

 

At the moment every WorkingTree has its own branch.  Remote

    transform,

    ui,

    urlutils,

    xml5,

    xml6,

    xml7,

import bzrlib.branch

from bzrlib.transport import get_transport

import bzrlib.ui

""")

 

from bzrlib import symbol_versioning

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference

from bzrlib.lockdir import LockDir

import bzrlib.mutabletree

from bzrlib.mutabletree import needs_tree_write_lock

    splitpath,

    supports_executable,

    )

from bzrlib.trace import mutter, note

from bzrlib.transport.local import LocalTransport

from bzrlib.progress import DummyProgress, ProgressPhase

class TreeEntry(object):

    """An entry that implements the minimum interface used by commands.

 

    InventoryEntries without ids - though that seems wrong. For now,

    this is a parallel hierarchy to InventoryEntry, and needs to become

    one of several things: decorates to that hierarchy, children of, or

    no InventoryEntry available - i.e. for unversioned objects.

    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003

    """

    def __eq__(self, other):

        # yes, this us ugly, TODO: best practice __eq__ style.

        return (isinstance(other, TreeEntry)

                and other.__class__ == self.__class__)

    def kind_character(self):

        return "???"

 

    not listed in the Inventory and vice versa.

    """

 

    def __init__(self, basedir='.',

                 branch=DEPRECATED_PARAMETER,

                 _inventory=None,

        else:

            # assume all other formats have their own control files.

            self._control_files = _control_files

        # update the whole cache up front and write to disk if anything changed;

        # in the future we might want to do this more selectively

        # two possible ways offer themselves : in self._unlock, write the cache

        wt_trans = self.bzrdir.get_workingtree_transport(None)

        cache_filename = wt_trans.local_abspath('stat-cache')

        self._hashcache = hashcache.HashCache(basedir, cache_filename,

        hc = self._hashcache

        hc.read()

        # is this scan needed ? it makes things kinda slow.

            # permitted to do this.

            self._set_inventory(_inventory, dirty=False)

        self._detect_case_handling()

 

    def _detect_case_handling(self):

        wt_trans = self.bzrdir.get_workingtree_transport(None)

    def supports_tree_reference(self):

        return False

 

    def _set_inventory(self, inv, dirty):

        """Set the internal cached inventory.

 

 

        """

        if path is None:

        control = bzrdir.BzrDir.open(path, _unsupported)

        return control.open_workingtree(_unsupported)

    @staticmethod

    def open_containing(path=None):

        """Open an existing working tree which has its root about path.

        This probes for a working tree at path and searches upwards from there.

 

        Basically we keep looking up until we find the control directory or

 

    def basis_tree(self):

        """Return RevisionTree for the current last revision.

        If the left most parent is a ghost then the returned tree will be an

        """

        try:

            revision_id = self.get_parent_ids()[0]

            # no parents, return an empty revision tree.

            # in the future this should return the tree for

            # 'empty:' - the implicit root empty tree.

        try:

            return self.revision_tree(revision_id)

        except errors.NoSuchRevision:

        # at this point ?

        try:

            return self.branch.repository.revision_tree(revision_id)

            # the basis tree *may* be a ghost or a low level error may have

            # its a ghost.

            if self.branch.repository.has_revision(revision_id):

                raise

            # the basis tree is a ghost so return an empty tree.

 

    def _cleanup(self):

        self._flush_ignore_list_cache()

 

    def relpath(self, path):

        """Return the local path portion from a given path.

        interpreted relative to the python current working directory.

        """

        return osutils.relpath(self.basedir, path)

    def has_filename(self, filename):

        return osutils.lexists(self.abspath(filename))

 

        if path is None:

            path = self.id2path(file_id)

 

    @needs_read_lock

    def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):

 

    def get_parent_ids(self):

        """See Tree.get_parent_ids.

        This implementation reads the pending merges list and last_revision

        value and uses that to decide what the parents list should be.

        """

        else:

            parents = [last_rev]

        try:

        except errors.NoSuchFile:

            pass

        else:

    def get_root_id(self):

        """Return the id of this trees root"""

        return self._inventory.root.file_id

    def _get_store_filename(self, file_id):

        ## XXX: badly named; this is not in the store at all

        return self.abspath(self.id2path(file_id))

    @needs_read_lock

    def clone(self, to_bzrdir, revision_id=None):

        """Duplicate this working tree into to_bzr, including all state.

        Specifically modified files are kept as modified, but

        ignored and unknown files are discarded.

 

        If you want to make a new line of development, see bzrdir.sprout()

 

        revision

            and this one merged in.

        """

        # assumes the target bzr dir format is compatible.

        self.copy_content_into(result, revision_id)

        return result

 

        """See MutableTree._add."""

        # TODO: Re-adding a file that is removed in the working copy

        # should probably put it back with the previous ID.

        # function - they should be part of lock_write and unlock.

        inv = self.inventory

        for f, file_id, kind in zip(files, ids, kinds):

                kind = 'tree-reference'

            return kind, None, None, None

        elif kind == 'symlink':

        else:

            return (kind, None, None, None)

 

 

    def _set_merges_from_parent_ids(self, parent_ids):

        merges = parent_ids[1:]

 

    @needs_tree_write_lock

    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):

        """Set the parent ids to revision_ids.

        See also set_parent_trees. This api will try to retrieve the tree data

        for each element of revision_ids from the trees repository. If you have

        tree data already available, it is more efficient to use

        for revision_id in revision_ids:

            _mod_revision.check_not_reserved_id(revision_id)

 

        if len(revision_ids) > 0:

            self.set_last_revision(revision_ids[0])

        else:

        self._check_parents_for_ghosts(parent_ids,

            allow_leftmost_as_ghost=allow_leftmost_as_ghost)

 

        if len(parent_ids) == 0:

            leftmost_parent_id = _mod_revision.NULL_REVISION

            leftmost_parent_tree = None

    def _put_rio(self, filename, stanzas, header):

        self._must_be_locked()

        my_file = rio_file(stanzas, header)

 

    @needs_write_lock # because merge pulls data into the branch.

    def merge_from_branch(self, branch, to_revision=None, from_revision=None,

    def merge_modified(self):

        """Return a dictionary of files modified by a merge.

 

        typically called after we make some automatic updates to the tree

        because of a merge.

 

        still in the working inventory and have that text hash.

        """

        try:

        except errors.NoSuchFile:

            return {}

        try:

                raise errors.MergeModifiedFormatError()

 

    @needs_write_lock

    def mkdir(self, path, file_id=None):

        return file_id

 

    def get_symlink_target(self, file_id):

 

    @needs_write_lock

    def subsume(self, other_tree):

        return False

 

    def _directory_may_be_tree_reference(self, relpath):

        # it's a tree reference, except that the root of the tree is not

        return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")

        # TODO: We could ask all the control formats whether they

    @needs_tree_write_lock

    def extract(self, file_id, format=None):

        """Extract a subtree from this tree.

        A new branch will be created, relative to the path for this tree.

        """

        self.flush()

                transport = transport.clone(name)

                transport.ensure_base()

            return transport

        sub_path = self.id2path(file_id)

        branch_transport = mkdirs(sub_path)

        if format is None:

        sio = StringIO()

        self._serialize(self._inventory, sio)

        sio.seek(0)

        self._inventory_is_modified = False

 

    def _kind(self, relpath):

        return osutils.file_kind(self.abspath(relpath))

 

 

        Lists, but does not descend into unversioned directories.

        This does not include files that have been deleted in this

 

        """

        # list_files is an iterator, so @needs_read_lock doesn't work properly

        # with it. So callers should be careful to always read_lock the tree.

            raise errors.ObjectNotLocked(self)

 

        inv = self.inventory

            yield ('', 'V', 'directory', inv.root.file_id, inv.root)

        # Convert these into local objects to save lookup times

        pathjoin = osutils.pathjoin

        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}

 

        # directory file_id, relative path, absolute path, reverse sorted children

        children.sort()

        # use a deque and popleft to keep them sorted, or if we use a plain

        # list and just reverse() them.

        children = collections.deque(children)

        while stack:

            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]

 

 

                # absolute path

                fap = from_dir_abspath + '/' + f

                f_ie = inv.get_child(from_dir_id, f)

                if f_ie:

                    c = 'V'

                    except KeyError:

                        yield fp[1:], c, fk, None, TreeEntry()

                    continue

                if fk != 'directory':

                    continue

 

            else:

                # if we finished all children, pop it off the stack

                stack.pop()

        to_dir must exist in the inventory.

 

        If to_dir exists and is a directory, the files are moved into

 

        Note that to_dir is only the last component of the new name;

        this doesn't change the directory.

                only_change_inv = True

            elif self.has_filename(from_rel) and not self.has_filename(to_rel):

                only_change_inv = False

                only_change_inv = False

            else:

                # something is wrong, so lets determine what exactly

        These are files in the working directory that are not versioned or

        control files or ignored.

        """

        # prevent race conditions with the lock

        return iter(

            [subp for subp in self.extras() if not self.is_ignored(subp)])

        :raises: NoSuchId if any fileid is not currently versioned.

        """

        for file_id in file_ids:

            if self._inventory.has_id(file_id):

                self._inventory.remove_recursive_id(file_id)

        if len(file_ids):

            # final unlock. However, until all methods of workingtree start

            # a read, it is more complex - we need to teach read_inventory

            # to know when to read, and when to not read first... and possibly

            # to save first when the in memory one may be corrupted.

            # so for now, we just only write it if it is indeed dirty.

            # - RBC 20060907

            self._write_inventory(self._inventory)

    def _iter_conflicts(self):

        conflicted = set()

        for info in self.list_files():

 

    @needs_write_lock

    def pull(self, source, overwrite=False, stop_revision=None,

        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()

        source.lock_read()

        try:

            old_revision_info = self.branch.last_revision_info()

            basis_tree = self.basis_tree()

            count = self.branch.pull(source, overwrite, stop_revision,

            new_revision_info = self.branch.last_revision_info()

            if new_revision_info != old_revision_info:

                pp.next_phase()

                # reuse the revisiontree we merged against to set the new

                # tree data.

                parent_trees = [(self.branch.last_revision(), new_basis_tree)]

                # layered well enough to prevent double handling.

                # XXX TODO: Fix the double handling: telling the tree about

                # the already known parent data is wasteful.

 

            fl = []

            for subf in os.listdir(dirabs):

                    continue

                if subf not in dir_entry.children:

                    if subf_norm != subf and can_access:

                        if subf_norm not in dir_entry.children:

                            fl.append(subf_norm)

                    else:

                        fl.append(subf)

            fl.sort()

            for subf in fl:

                subp = pathjoin(path, subf)

    def _reset_data(self):

        """Reset transient data that cannot be revalidated."""

        self._inventory_is_modified = False

        self._set_inventory(result, dirty=False)

 

    @needs_tree_write_lock

 

    def _change_last_revision(self, new_revision):

        """Template method part of set_last_revision to perform the change.

        This is used to allow WorkingTree3 instances to not affect branch

        when their last revision is set.

        """

        """Write the basis inventory XML to the basis-inventory file"""

        path = self._basis_inventory_name()

        sio = StringIO(xml)

 

    def _create_basis_xml_from_inventory(self, revision_id, inventory):

        """Create the text that will be saved in basis-inventory"""

        # as commit already has that ready-to-use [while the format is the

        # same, that is].

        try:

            # but is easier to understand. We can/should put a conditional

            # in here based on whether the inventory is in the latest format

            # - perhaps we should repack all inventories on a repository

            # upgrade ?

            # the fast path is to copy the raw xml from the repository. If the

            # revision_id is set. We must check for this full string, because a

            # root node id can legitimately look like 'revision_id' but cannot

            # contain a '"'.

            xml = self.branch.repository.get_inventory_xml(new_revision)

            firstline = xml.split('\n', 1)[0]

                'format="7"' not in firstline):

                inv = self.branch.repository.deserialise_inventory(

                    new_revision, xml)

    def read_basis_inventory(self):

        """Read the cached basis inventory."""

        path = self._basis_inventory_name()

    @needs_read_lock

    def read_working_inventory(self):

        """Read the working inventory.

        :raises errors.InventoryModified: read_working_inventory will fail

            when the current in memory inventory has been modified.

        """

        # XXX: Deprecate this.

        # ElementTree does its own conversion from UTF-8, so open in

        # binary.

        if self._inventory_is_modified:

            raise errors.InventoryModified(self)

        self._set_inventory(result, dirty=False)

        return result

 

            # Recurse directory and add all files

            # so we can check if they have changed.

            for parent_info, file_infos in\

                    # Is it versioned or ignored?

                    if self.path2id(relpath) or self.is_ignored(relpath):

                        # Add nested content for deletion.

            filename = self.relpath(abspath)

            if len(filename) > 0:

                new_files.add(filename)

 

        files = list(new_files)

 

                        tree_delta.unversioned.extend((unknown_file,))

                raise errors.BzrRemoveChangedFilesError(tree_delta)

 

        # do this before any modifications to inventory.

        for f in files:

            fid = self.path2id(f)

            name = os.path.basename(path)

            if name == "":

                continue

            if kind == 'directory':

                inv.add(InventoryDirectory(file_id, name, parent))

            elif kind == 'file':

    @needs_tree_write_lock

    def set_root_id(self, file_id):

        """Set the root id for this tree."""

        if file_id is None:

            raise ValueError(

                'WorkingTree.set_root_id with fileid=None')

    def _set_root_id(self, file_id):

        """Set the root id for this tree, in a format specific manner.

 

            present in the current inventory or an error will occur. It must

            not be None, but rather a valid file id.

        """

 

    def unlock(self):

        """See Branch.unlock.

        WorkingTree locking just uses the Branch locking facilities.

        This is current because all working trees have an embedded branch

        within them. IF in the future, we were to make branch data shareable

        would probably want to lock both the local tree, and the branch.

        """

        raise NotImplementedError(self.unlock)

        # cant set that until we update the working trees last revision to be

        # one from the new branch, because it will just get absorbed by the

        # parent de-duplication logic.

        # We MUST save it even if an error occurs, because otherwise the users

        # local work is unreferenced and will appear to have been lost.

        result = 0

        try:

            last_rev = self.get_parent_ids()[0]

            parent_trees = [(self.branch.last_revision(), to_tree)]

            merges = self.get_parent_ids()[1:]

            # Ideally we ask the tree for the trees here, that way the working

            # lazy initialised tree. dirstate for instance will have the trees

            # in ram already, whereas a last-revision + basis-inventory tree

            # will not, but also does not need them when setting parents.

                    # value.

                    bzrdir_loc = bisect_left(cur_disk_dir_content,

                        ('.bzr', '.bzr'))

                        # we dont yield the contents of, or, .bzr itself.

                        del cur_disk_dir_content[bzrdir_loc]

            if inv_finished:

                relroot = ""

            # FIXME: stash the node in pending

            entry = inv[top_id]

            yield (currentdir[0], entry.file_id), dirblock

            # push the user specified dirs from dirblock

            for dir in reversed(dirblock):

        self.set_conflicts(un_resolved)

        return un_resolved, resolved

 

    def _validate(self):

        """Validate internal structures.

 

        """

        return

 

 

class WorkingTree2(WorkingTree):

    """This is the Format 2 working tree.

 

     - uses os locks for locking.

     - uses the branch last-revision.

    """

            if self._inventory_is_modified:

                self.flush()

            self._write_hashcache_if_dirty()

        # reverse order of locking.

        try:

            return self._control_files.unlock()

    def _last_revision(self):

        """See Mutable.last_revision."""

        try:

        except errors.NoSuchFile:

            return _mod_revision.NULL_REVISION

 

        """See WorkingTree._change_last_revision."""

        if revision_id is None or revision_id == NULL_REVISION:

            try:

            except errors.NoSuchFile:

                pass

            return False

        else:

            return True

 

    @needs_tree_write_lock

    def set_conflicts(self, conflicts):

                      CONFLICT_HEADER_1)

 

    @needs_tree_write_lock

    @needs_read_lock

    def conflicts(self):

        try:

        except errors.NoSuchFile:

            return _mod_conflicts.ConflictList()

        try:

                raise errors.ConflictFormatError()

 

    def unlock(self):

        # do non-implementation specific cleanup

     * a format string,

     * an open routine.

 

    during workingtree opening. Its not required that these be instances, they

    whether state is needed for a given format or not.

 

    Once a format is deprecated, just deprecate the initialize and open

    object will be created every time regardless.

    """

 

        """Is this format supported?

 

        Supported formats can be initialized and opened.

        some other features depending on the reason for not being supported.

        """

        return True