~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

import itertools

import operator

import stat

import re

 

import bzrlib

    branch,

    bzrdir,

    conflicts as _mod_conflicts,

    errors,

    generate_ids,

    globbing,

    hashcache,

    ignores,

    merge,

    revision as _mod_revision,

    revisiontree,

    textui,

    trace,

    transform,

    ui,

    xml5,

    xml7,

    )

import bzrlib.branch

from bzrlib.transport import get_transport

""")

 

from bzrlib import symbol_versioning

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.lockdir import LockDir

import bzrlib.mutabletree

from bzrlib.mutabletree import needs_tree_write_lock

from bzrlib import osutils

from bzrlib.osutils import (

    file_kind,

    isdir,

    normpath,

    pathjoin,

    realpath,

    safe_unicode,

    splitpath,

    supports_executable,

    )

from bzrlib.trace import mutter, note

from bzrlib.transport.local import LocalTransport

from bzrlib.progress import DummyProgress, ProgressPhase

from bzrlib.rio import RioReader, rio_file, Stanza

 

 

MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"

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,

        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.

            self._set_inventory(_inventory, dirty=False)

        self._detect_case_handling()

        self._rules_searcher = None

 

    def _detect_case_handling(self):

        wt_trans = self.bzrdir.get_workingtree_transport(None)

        self._control_files.break_lock()

        self.branch.break_lock()

 

    def requires_rich_root(self):

        return self._format.requires_rich_root

 

    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:

            return self.branch.repository.revision_tree(revision_id)

        except (errors.RevisionNotPresent, errors.NoSuchRevision):

            # 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):

        incorrectly attributed to CURRENT_REVISION (but after committing, the

        attribution will be correct).

        """

 

    def _get_ancestors(self, default_revision):

        ancestors = set([default_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.

        """

    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.

        """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:]

        self._transport.put_bytes('pending-merges', '\n'.join(merges),

 

    def _filter_parent_ids_by_ancestry(self, revision_ids):

        """Check that all merged revisions are proper 'heads'.

 

        This will always return the first revision_id, and any merged revisions

        """

        if len(revision_ids) == 0:

            return revision_ids

    @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

        self._must_be_locked()

        my_file = rio_file(stanzas, header)

        self._transport.put_file(filename, my_file,

 

    @needs_write_lock # because merge pulls data into the branch.

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

            branch.last_revision().

        """

        from bzrlib.merge import Merger, Merge3Merger

        try:

            merger = Merger(self.branch, this_tree=self, pb=pb)

            merger.pp = ProgressPhase("Merge phase", 5, pb)

    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.

 

            hashfile = self._transport.get('merge-hashes')

        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:

            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)

        else:

            tree_bzrdir = branch_bzrdir

        wt.set_parent_ids(self.get_parent_ids())

        my_inv = self.inventory

        new_root = my_inv[file_id]

        my_inv.remove_recursive_id(file_id)

        new_root.parent_id = None

        self._serialize(self._inventory, sio)

        sio.seek(0)

        self._transport.put_file('inventory', sio,

        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.

        inv = self.inventory

        for entry in moved:

            try:

                    entry.to_tail, entry.to_parent_id, entry.from_rel,

                    entry.from_tail, entry.from_parent_id,

                    entry.only_change_inv))

        from_tail = splitpath(from_rel)[-1]

        from_id = inv.path2id(from_rel)

        if from_id is None:

        from_parent_id = from_entry.parent_id

        to_dir, to_tail = os.path.split(to_rel)

        to_dir_id = inv.path2id(to_dir)

        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,

        source.lock_read()

        try:

            pp = ProgressPhase("Pull phase", 2, top_pb)

            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()

                repository = self.branch.repository

                basis_tree.lock_read()

                try:

                    new_basis_tree = self.branch.basis_tree()

                # 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:

                    try:

                            fl.append(subf_norm)

                    else:

                        fl.append(subf)

            fl.sort()

            for subf in fl:

                subp = pathjoin(path, subf)

 

    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.

        """

        path = self._basis_inventory_name()

        sio = StringIO(xml)

        self._transport.put_file(path, sio,

 

    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)

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

        path = self._basis_inventory_name()

        return self._transport.get_bytes(path)

    @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.

                        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)

            if filenames is None and len(self.get_parent_ids()) > 1:

                parent_trees = []

                last_revision = self.last_revision()

                    if basis_tree is None:

                        basis_tree = self.basis_tree()

                        basis_tree.lock_read()

    def set_inventory(self, new_inventory_list):

        from bzrlib.inventory import (Inventory,

                                      InventoryDirectory,

                                      InventoryFile,

                                      InventoryLink)

        inv = Inventory(self.get_root_id())

            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:

        return un_resolved, resolved

 

    @needs_read_lock

        tree_basis = self.basis_tree()

        tree_basis.lock_read()

        try:

            if len(list(repo_basis.iter_changes(tree_basis))) > 0:

                raise errors.BzrCheckError(

                    "Mismatched basis inventory content.")

                self)._get_rules_searcher(default_searcher)

        return self._rules_searcher

 

 

class WorkingTree2(WorkingTree):

    """This is the Format 2 working tree.

 

     - uses os locks for locking.

     - uses the branch last-revision.

    """