~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2010 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

"""WorkingTree object and friends.

A WorkingTree represents the editable working copy of a branch.

Operations which represent the WorkingTree are also done here,

such as renaming or adding files.  The WorkingTree has an inventory

which is updated by these operations.  A commit produces a

new revision based on the workingtree and its inventory.

At the moment every WorkingTree has its own branch.  Remote

WorkingTrees aren't supported.

To get a WorkingTree, call bzrdir.open_workingtree() or

WorkingTree.open(dir).

"""

from cStringIO import StringIO

import os

import sys

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

from bisect import bisect_left

import collections

import errno

import itertools

import operator

import stat

import re

import bzrlib

from bzrlib import (

    branch,

    bzrdir,

    conflicts as _mod_conflicts,

    controldir,

    errors,

    generate_ids,

    globbing,

    graph as _mod_graph,

    hashcache,

    ignores,

    inventory,

    merge,

    revision as _mod_revision,

    revisiontree,

    trace,

    transform,

    transport,

    ui,

    views,

    xml5,

    xml7,

    )

from bzrlib.workingtree_4 import (

    WorkingTreeFormat4,

    WorkingTreeFormat5,

    WorkingTreeFormat6,

    )

""")

from bzrlib import symbol_versioning

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.lock import LogicalLockResult

from bzrlib.lockable_files import LockableFiles

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.filters import filtered_input_file

from bzrlib.trace import mutter, note

from bzrlib.transport.local import LocalTransport

from bzrlib.revision import CURRENT_REVISION

from bzrlib.rio import RioReader, rio_file, Stanza

from bzrlib.symbol_versioning import (

    deprecated_passed,

    DEPRECATED_PARAMETER,

    )

MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"

# TODO: Modifying the conflict objects or their type is currently nearly

# impossible as there is no clear relationship between the working tree format

# and the conflict list file format.

CONFLICT_HEADER_1 = "BZR conflict list format 1"

ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT

class TreeEntry(object):

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

    This needs further inspection, it may be better to have

    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

    parents of it.

    Another note is that these objects are currently only used when there is

    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 "???"

class TreeDirectory(TreeEntry):

    """See TreeEntry. This is a directory in a working tree."""

    def __eq__(self, other):

        return (isinstance(other, TreeDirectory)

                and other.__class__ == self.__class__)

    def kind_character(self):

        return "/"

class TreeFile(TreeEntry):

    """See TreeEntry. This is a regular file in a working tree."""

    def __eq__(self, other):

        return (isinstance(other, TreeFile)

                and other.__class__ == self.__class__)

    def kind_character(self):

        return ''

class TreeLink(TreeEntry):

    """See TreeEntry. This is a symlink in a working tree."""

    def __eq__(self, other):

        return (isinstance(other, TreeLink)

                and other.__class__ == self.__class__)

    def kind_character(self):

        return ''

class WorkingTree(bzrlib.mutabletree.MutableTree,

    controldir.ControlComponent):

    """Working copy tree.

    The inventory is held in the `Branch` working-inventory, and the

    files are in a directory on disk.

    It is possible for a `WorkingTree` to have a filename which is

    not listed in the Inventory and vice versa.

    :ivar basedir: The root of the tree on disk. This is a unicode path object

        (as opposed to a URL).

    """

    # override this to set the strategy for storing views

    def _make_views(self):

        return views.DisabledViews(self)

    def __init__(self, basedir='.',

                 branch=DEPRECATED_PARAMETER,

                 _inventory=None,

                 _control_files=None,

                 _internal=False,

                 _format=None,

                 _bzrdir=None):

        """Construct a WorkingTree instance. This is not a public API.

        :param branch: A branch to override probing for the branch.

        """

        self._format = _format

        self.bzrdir = _bzrdir

        if not _internal:

            raise errors.BzrError("Please use bzrdir.open_workingtree or "

                "WorkingTree.open() to obtain a WorkingTree.")

        basedir = safe_unicode(basedir)

        mutter("opening working tree %r", basedir)

        if deprecated_passed(branch):

            self._branch = branch

        else:

            self._branch = self.bzrdir.open_branch()

        self.basedir = realpath(basedir)

        # if branch is at our basedir and is a format 6 or less

        if isinstance(self._format, WorkingTreeFormat2):

            # share control object

            self._control_files = self.branch.control_files

        else:

            # assume all other formats have their own control files.

            self._control_files = _control_files

        self._transport = self._control_files._transport

        # 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

        # if needed, or, when the cache sees a change, append it to the hash

        # cache file, and have the parser take the most recent entry for a

        # given path only.

        wt_trans = self.bzrdir.get_workingtree_transport(None)

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

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

            self.bzrdir._get_file_mode(),

            self._content_filter_stack_provider())

        hc = self._hashcache

        hc.read()

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

        #hc.scan()

        if hc.needs_write:

            mutter("write hc")

            hc.write()

        if _inventory is None:

            # This will be acquired on lock_read() or lock_write()

            self._inventory_is_modified = False

            self._inventory = None

        else:

            # the caller of __init__ has provided an inventory,

            # we assume they know what they are doing - as its only

            # the Format factory and creation methods that are

            # permitted to do this.

            self._set_inventory(_inventory, dirty=False)

        self._detect_case_handling()

        self._rules_searcher = None

        self.views = self._make_views()

    @property

    def user_transport(self):

        return self.bzrdir.user_transport

    @property

    def control_transport(self):

        return self._transport

    def _detect_case_handling(self):

        wt_trans = self.bzrdir.get_workingtree_transport(None)

        try:

            wt_trans.stat("FoRMaT")

        except errors.NoSuchFile:

            self.case_sensitive = True

        else:

            self.case_sensitive = False

        self._setup_directory_is_tree_reference()

    branch = property(

        fget=lambda self: self._branch,

        doc="""The branch this WorkingTree is connected to.

            This cannot be set - it is reflective of the actual disk structure

            the working tree has been constructed from.

            """)

    def break_lock(self):

        """Break a lock if one is present from another instance.

        Uses the ui factory to ask for confirmation if the lock may be from

        an active process.

        This will probe the repository for its lock as well.

        """

        self._control_files.break_lock()

        self.branch.break_lock()

    def _get_check_refs(self):

        """Return the references needed to perform a check of this tree.

        The default implementation returns no refs, and is only suitable for

        trees that have no local caching and can commit on ghosts at any time.

        :seealso: bzrlib.check for details about check_refs.

        """

        return []

    def requires_rich_root(self):

        return self._format.requires_rich_root

    def supports_tree_reference(self):

        return False

    def supports_content_filtering(self):

        return self._format.supports_content_filtering()

    def supports_views(self):

        return self.views.supports_views()

    def _set_inventory(self, inv, dirty):

        """Set the internal cached inventory.

        :param inv: The inventory to set.

        :param dirty: A boolean indicating whether the inventory is the same

            logical inventory as whats on disk. If True the inventory is not

            the same and should be written to disk or data will be lost, if

            False then the inventory is the same as that on disk and any

            serialisation would be unneeded overhead.

        """

        self._inventory = inv

        self._inventory_is_modified = dirty

    @staticmethod

    def open(path=None, _unsupported=False):

        """Open an existing working tree at path.

        """

        if path is None:

            path = osutils.getcwd()

        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

        run into /.  If there isn't one, raises NotBranchError.

        TODO: give this a new exception.

        If there is one, it is returned, along with the unused portion of path.

        :return: The WorkingTree that contains 'path', and the rest of path

        """

        if path is None:

            path = osutils.getcwd()

        control, relpath = bzrdir.BzrDir.open_containing(path)

        return control.open_workingtree(), relpath

    @staticmethod

    def open_containing_paths(file_list, default_directory=None,

                              canonicalize=True, apply_view=True):

        """Open the WorkingTree that contains a set of paths.

        Fail if the paths given are not all in a single tree.

        This is used for the many command-line interfaces that take a list of

        any number of files and that require they all be in the same tree.

        """

        if default_directory is None:

            default_directory = u'.'

        # recommended replacement for builtins.internal_tree_files

        if file_list is None or len(file_list) == 0:

            tree = WorkingTree.open_containing(default_directory)[0]

            # XXX: doesn't really belong here, and seems to have the strange

            # side effect of making it return a bunch of files, not the whole

            # tree -- mbp 20100716

            if tree.supports_views() and apply_view:

                view_files = tree.views.lookup_view()

                if view_files:

                    file_list = view_files

                    view_str = views.view_display_str(view_files)

                    note("Ignoring files outside view. View is %s" % view_str)

            return tree, file_list

        if default_directory == u'.':

            seed = file_list[0]

        else:

            seed = default_directory

            file_list = [osutils.pathjoin(default_directory, f)

                         for f in file_list]

        tree = WorkingTree.open_containing(seed)[0]

        return tree, tree.safe_relpath_files(file_list, canonicalize,

                                             apply_view=apply_view)

    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):

        """Convert file_list into a list of relpaths in tree.

        :param self: A tree to operate on.

        :param file_list: A list of user provided paths or None.

        :param apply_view: if True and a view is set, apply it or check that

            specified files are within it

        :return: A list of relative paths.

        :raises errors.PathNotChild: When a provided path is in a different self

            than self.

        """

        if file_list is None:

            return None

        if self.supports_views() and apply_view:

            view_files = self.views.lookup_view()

        else:

            view_files = []

        new_list = []

        # self.relpath exists as a "thunk" to osutils, but canonical_relpath

        # doesn't - fix that up here before we enter the loop.

        if canonicalize:

            fixer = lambda p: osutils.canonical_relpath(self.basedir, p)

        else:

            fixer = self.relpath

        for filename in file_list:

            relpath = fixer(osutils.dereference_path(filename))

            if view_files and not osutils.is_inside_any(view_files, relpath):

                raise errors.FileOutsideView(filename, view_files)

            new_list.append(relpath)

        return new_list

    @staticmethod

    def open_downlevel(path=None):

        """Open an unsupported working tree.

        Only intended for advanced situations like upgrading part of a bzrdir.

        """

        return WorkingTree.open(path, _unsupported=True)

    @staticmethod

    def find_trees(location):

        def list_current(transport):

            return [d for d in transport.list_dir('') if d != '.bzr']

        def evaluate(bzrdir):

            try:

                tree = bzrdir.open_workingtree()

            except errors.NoWorkingTree:

                return True, None

            else:

                return True, tree

        t = transport.get_transport(location)

        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,

                                              list_current=list_current)

        return [tr for tr in iterator if tr is not None]

    # should be deprecated - this is slow and in any case treating them as a

    # container is (we now know) bad style -- mbp 20070302

    ## @deprecated_method(zero_fifteen)

    def __iter__(self):

        """Iterate through file_ids for this tree.

        file_ids are in a WorkingTree if they are in the working inventory

        and the working file exists.

        """

        inv = self._inventory

        for path, ie in inv.iter_entries():

            if osutils.lexists(self.abspath(path)):

                yield ie.file_id

    def all_file_ids(self):

        """See Tree.iter_all_file_ids"""

        return set(self.inventory)

    def __repr__(self):

        return "<%s of %s>" % (self.__class__.__name__,

                               getattr(self, 'basedir', None))

    def abspath(self, filename):

        return pathjoin(self.basedir, filename)

    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

        empty tree - one obtained by calling

        repository.revision_tree(NULL_REVISION).

        """

        try:

            revision_id = self.get_parent_ids()[0]

        except IndexError:

            # no parents, return an empty revision tree.

            # in the future this should return the tree for

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

            return self.branch.repository.revision_tree(

                       _mod_revision.NULL_REVISION)

        try:

            return self.revision_tree(revision_id)

        except errors.NoSuchRevision:

            pass

        # No cached copy available, retrieve from the repository.

        # FIXME? RBC 20060403 should we cache the inventory locally

        # at this point ?

        try:

            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

            # occurred. If the revision is present, its a problem, if its not

            # its a ghost.

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

                raise

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

            return self.branch.repository.revision_tree(

                       _mod_revision.NULL_REVISION)

    def _cleanup(self):

        self._flush_ignore_list_cache()

    def relpath(self, path):

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

        The path may be absolute or relative. If its a relative path it is

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

    def get_file(self, file_id, path=None, filtered=True):

        return self.get_file_with_stat(file_id, path, filtered=filtered)[0]

    def get_file_with_stat(self, file_id, path=None, filtered=True,

        _fstat=os.fstat):

        """See Tree.get_file_with_stat."""

        if path is None:

            path = self.id2path(file_id)

        file_obj = self.get_file_byname(path, filtered=False)

        stat_value = _fstat(file_obj.fileno())

        if filtered and self.supports_content_filtering():

            filters = self._content_filter_stack(path)

            file_obj = filtered_input_file(file_obj, filters)

        return (file_obj, stat_value)

    def get_file_text(self, file_id, path=None, filtered=True):

        my_file = self.get_file(file_id, path=path, filtered=filtered)

        try:

            return my_file.read()

        finally:

            my_file.close()

    def get_file_byname(self, filename, filtered=True):

        path = self.abspath(filename)

        f = file(path, 'rb')

        if filtered and self.supports_content_filtering():

            filters = self._content_filter_stack(filename)

            return filtered_input_file(f, filters)

        else:

            return f

    def get_file_lines(self, file_id, path=None, filtered=True):

        """See Tree.get_file_lines()"""

        file = self.get_file(file_id, path, filtered=filtered)

        try:

            return file.readlines()

        finally:

            file.close()

    @needs_read_lock

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

        """See Tree.annotate_iter

        This implementation will use the basis tree implementation if possible.

        Lines not in the basis are attributed to CURRENT_REVISION

        If there are pending merges, lines added by those merges will be

        incorrectly attributed to CURRENT_REVISION (but after committing, the

        attribution will be correct).

        """

        maybe_file_parent_keys = []

        for parent_id in self.get_parent_ids():

            try:

                parent_tree = self.revision_tree(parent_id)

            except errors.NoSuchRevisionInTree:

                parent_tree = self.branch.repository.revision_tree(parent_id)

            parent_tree.lock_read()

            try:

                if file_id not in parent_tree:

                    continue

                ie = parent_tree.inventory[file_id]

                if ie.kind != 'file':

                    # Note: this is slightly unnecessary, because symlinks and

                    # directories have a "text" which is the empty text, and we

                    # know that won't mess up annotations. But it seems cleaner

                    continue

                parent_text_key = (file_id, ie.revision)

                if parent_text_key not in maybe_file_parent_keys:

                    maybe_file_parent_keys.append(parent_text_key)

            finally:

                parent_tree.unlock()

        graph = _mod_graph.Graph(self.branch.repository.texts)

        heads = graph.heads(maybe_file_parent_keys)

        file_parent_keys = []

        for key in maybe_file_parent_keys:

            if key in heads:

                file_parent_keys.append(key)

        # Now we have the parents of this content

        annotator = self.branch.repository.texts.get_annotator()

        text = self.get_file_text(file_id)

        this_key =(file_id, default_revision)

        annotator.add_special_text(this_key, file_parent_keys, text)

        annotations = [(key[-1], line)

                       for key, line in annotator.annotate_flat(this_key)]

        return annotations

    def _get_ancestors(self, default_revision):

        ancestors = set([default_revision])

        for parent_id in self.get_parent_ids():

            ancestors.update(self.branch.repository.get_ancestry(

                             parent_id, topo_sorted=False))

        return ancestors

    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.

        """

        last_rev = _mod_revision.ensure_null(self._last_revision())

        if _mod_revision.NULL_REVISION == last_rev:

            parents = []

        else:

            parents = [last_rev]

        try:

            merges_bytes = self._transport.get_bytes('pending-merges')

        except errors.NoSuchFile:

            pass

        else:

            for l in osutils.split_lines(merges_bytes):

                revision_id = l.rstrip('\n')

                parents.append(revision_id)

        return parents

    @needs_read_lock

    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

            If not None, the cloned tree will have its last revision set to

            revision, and difference between the source trees last revision

            and this one merged in.

        """

        # assumes the target bzr dir format is compatible.

        result = to_bzrdir.create_workingtree()

        self.copy_content_into(result, revision_id)

        return result

    @needs_read_lock

    def copy_content_into(self, tree, revision_id=None):

        """Copy the current content and user files of this tree into tree."""

        tree.set_root_id(self.get_root_id())

        if revision_id is None:

            merge.transform_tree(tree, self)

        else:

            # TODO now merge from tree.last_revision to revision (to preserve

            # user local changes)

            merge.transform_tree(tree, self)

            tree.set_parent_ids([revision_id])

    def id2abspath(self, file_id):

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

    def has_id(self, file_id):