/brz/remove-bazaar

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

At the moment every WorkingTree has its own branch.  Remote

WorkingTrees aren't supported.

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

WorkingTree.open(dir).

"""

from __future__ import absolute_import

import errno

import os

import re

import shutil

import sys

import breezy

from .lazy_import import lazy_import

lazy_import(globals(), """

import stat

from breezy import (

    branch,

    conflicts as _mod_conflicts,

    controldir,

    errors,

    filters as _mod_filters,

    generate_ids,

    merge,

    revision as _mod_revision,

    transform,

    transport,

    ui,

    views,

    )

""")

from . import (

    osutils,

    )

from .i18n import gettext

from . import mutabletree

from .sixish import (

    text_type,

    )

from .trace import mutter, note

ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT

class SettingFileIdUnsupported(errors.BzrError):

    _fmt = "This format does not support setting file ids."

class ShelvingUnsupported(errors.BzrError):

    _fmt = "This format does not support shelving changes."

class WorkingTree(mutabletree.MutableTree,

    controldir.ControlComponent):

    """Working copy tree.

    :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=None,

                 _internal=False,

                 _transport=None,

                 _format=None,

                 _controldir=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.controldir = _controldir

        if not _internal:

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

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

        basedir = osutils.safe_unicode(basedir)

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

        if branch is not None:

            self._branch = branch

        else:

            self._branch = self.controldir.open_branch()

        self.basedir = osutils.realpath(basedir)

        self._transport = _transport

        self._rules_searcher = None

        self.views = self._make_views()

    @property

    def user_transport(self):

        return self.controldir.user_transport

    @property

    def control_transport(self):

        return self._transport

    def is_control_filename(self, filename):

        """True if filename is the name of a control file in this tree.

        :param filename: A filename within the tree. This is a relative path

            from the root of this tree.

        This is true IF and ONLY IF the filename is part of the meta data

        that bzr controls in this tree. I.E. a random .bzr directory placed

        on disk will not be a control file for this tree.

        """

        return self.controldir.is_control_filename(filename)

    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 has_versioned_directories(self):

        """See `Tree.has_versioned_directories`."""

        return self._format.supports_versioned_directories

    def _supports_executable(self):

        if sys.platform == 'win32':

            return False

        # FIXME: Ideally this should check the file system

        return True

    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.

        """

        raise NotImplementedError(self.break_lock)

    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 supports_setting_file_ids(self):

        return self._format.supports_setting_file_ids

    def get_config_stack(self):

        """Retrieve the config stack for this tree.

        :return: A ``breezy.config.Stack``

        """

        # For the moment, just provide the branch config stack.

        return self.branch.get_config_stack()

    @staticmethod

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

        """Open an existing working tree at path.

        """

        if path is None:

            path = osutils.getcwd()

        control = controldir.ControlDir.open(path, _unsupported=_unsupported)

        return control.open_workingtree(unsupported=_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 = controldir.ControlDir.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(gettext("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 views.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 controldir.

        """

        return WorkingTree.open(path, _unsupported=True)

    @staticmethod

    def find_trees(location):

        def list_current(transport):

            return [d for d in transport.list_dir('')

                    if not controldir.is_control_filename(d)]

        def evaluate(controldir):

            try:

                tree = controldir.open_workingtree()

            except errors.NoWorkingTree:

                return True, None

            else:

                return True, tree

        t = transport.get_transport(location)

        iterator = controldir.ControlDir.find_controldirs(t, evaluate=evaluate,

                                              list_current=list_current)

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

    def __repr__(self):

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

                               getattr(self, 'basedir', None))

    def abspath(self, filename):

        return osutils.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 tree 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 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, path, file_id=None, filtered=True):

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

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

                           _fstat=osutils.fstat):

        """See Tree.get_file_with_stat."""

        abspath = self.abspath(path)

        file_obj = file(abspath, 'rb')

        stat_value = _fstat(file_obj.fileno())

        if filtered and self.supports_content_filtering():

            filters = self._content_filter_stack(path)

            file_obj = _mod_filters.filtered_input_file(file_obj, filters)

        return (file_obj, stat_value)

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

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

        try:

            return my_file.read()

        finally:

            my_file.close()

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

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

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

        try:

            return file.readlines()

        finally:

            file.close()

    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

    def get_root_id(self):

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

        raise NotImplementedError(self.get_root_id)

    def clone(self, to_controldir, 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 ControlDir.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.

        """

        with self.lock_read():

            # assumes the target bzr dir format is compatible.

            result = to_controldir.create_workingtree()

            self.copy_content_into(result, revision_id)

            return result

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

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

        with self.lock_read():

            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)

                try:

                    other_tree = self.revision_tree(revision_id)

                except errors.NoSuchRevision:

                    other_tree = self.branch.repository.revision_tree(

                            revision_id)

                merge.transform_tree(tree, other_tree)

                if revision_id == _mod_revision.NULL_REVISION:

                    new_parents = []

                else:

                    new_parents = [revision_id]

                tree.set_parent_ids(new_parents)

    def id2abspath(self, file_id):

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

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

        """See Tree.get_file_size"""

        # XXX: this returns the on-disk size; it should probably return the

        # canonical size

        try:

            return os.path.getsize(self.abspath(path))

        except OSError as e:

            if e.errno != errno.ENOENT:

                raise

            else:

                return None

    def _gather_kinds(self, files, kinds):

        """See MutableTree._gather_kinds."""

        with self.lock_tree_write():

            for pos, f in enumerate(files):

                if kinds[pos] is None:

                    fullpath = osutils.normpath(self.abspath(f))

                    try:

                        kinds[pos] = osutils.file_kind(fullpath)

                    except OSError as e:

                        if e.errno == errno.ENOENT:

                            raise errors.NoSuchFile(fullpath)

    def add_parent_tree_id(self, revision_id, allow_leftmost_as_ghost=False):

        """Add revision_id as a parent.

        This is equivalent to retrieving the current list of parent ids

        and setting the list to its value plus revision_id.

        :param revision_id: The revision id to add to the parent list. It may

            be a ghost revision as long as its not the first parent to be

            added, or the allow_leftmost_as_ghost parameter is set True.

        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.

        """

        with self.lock_write():

            parents = self.get_parent_ids() + [revision_id]

            self.set_parent_ids(parents, allow_leftmost_as_ghost=len(parents) > 1

                or allow_leftmost_as_ghost)

    def add_parent_tree(self, parent_tuple, allow_leftmost_as_ghost=False):

        """Add revision_id, tree tuple as a parent.

        This is equivalent to retrieving the current list of parent trees

        and setting the list to its value plus parent_tuple. See also

        add_parent_tree_id - if you only have a parent id available it will be

        simpler to use that api. If you have the parent already available, using

        this api is preferred.

        :param parent_tuple: The (revision id, tree) to add to the parent list.

            If the revision_id is a ghost, pass None for the tree.

        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.

        """

        with self.lock_tree_write():

            parent_ids = self.get_parent_ids() + [parent_tuple[0]]

            if len(parent_ids) > 1:

                # the leftmost may have already been a ghost, preserve that if it

                # was.

                allow_leftmost_as_ghost = True

            self.set_parent_ids(parent_ids,

                allow_leftmost_as_ghost=allow_leftmost_as_ghost)

    def add_pending_merge(self, *revision_ids):

        with self.lock_tree_write():

            # TODO: Perhaps should check at this point that the

            # history of the revision is actually present?

            parents = self.get_parent_ids()

            updated = False

            for rev_id in revision_ids:

                if rev_id in parents:

                    continue

                parents.append(rev_id)

                updated = True

            if updated:

                self.set_parent_ids(parents, allow_leftmost_as_ghost=True)

    def path_content_summary(self, path, _lstat=os.lstat,

        _mapper=osutils.file_kind_from_stat_mode):

        """See Tree.path_content_summary."""

        abspath = self.abspath(path)

        try:

            stat_result = _lstat(abspath)

        except OSError as e:

            if getattr(e, 'errno', None) == errno.ENOENT:

                # no file.

                return ('missing', None, None, None)

            # propagate other errors

            raise

        kind = _mapper(stat_result.st_mode)

        if kind == 'file':

            return self._file_content_summary(path, stat_result)

        elif kind == 'directory':

            # perhaps it looks like a plain directory, but it's really a

            # reference.

            if self._directory_is_tree_reference(path):

                kind = 'tree-reference'

            return kind, None, None, None

        elif kind == 'symlink':

            target = osutils.readlink(abspath)

            return ('symlink', None, None, target)

        else:

            return (kind, None, None, None)

    def _file_content_summary(self, path, stat_result):

        size = stat_result.st_size

        executable = self._is_executable_from_path_and_stat(path, stat_result)

        # try for a stat cache lookup

        return ('file', size, executable, self._sha_from_stat(

            path, stat_result))

    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):

        """Common ghost checking functionality from set_parent_*.

        This checks that the left hand-parent exists if there are any

        revisions present.

        """

        if len(revision_ids) > 0:

            leftmost_id = revision_ids[0]

            if (not allow_leftmost_as_ghost and not

                self.branch.repository.has_revision(leftmost_id)):

                raise errors.GhostRevisionUnusableHere(leftmost_id)

    def _set_merges_from_parent_ids(self, parent_ids):

        merges = parent_ids[1:]

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

            mode=self.controldir._get_file_mode())

    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

        which are

        """

        if len(revision_ids) == 0:

            return revision_ids

        graph = self.branch.repository.get_graph()

        heads = graph.heads(revision_ids)

        new_revision_ids = revision_ids[:1]

        for revision_id in revision_ids[1:]:

            if revision_id in heads and revision_id not in new_revision_ids:

                new_revision_ids.append(revision_id)

        if new_revision_ids != revision_ids:

            mutter('requested to set revision_ids = %s,'

                         ' but filtered to %s', revision_ids, new_revision_ids)

        return new_revision_ids

    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

        set_parent_trees rather than set_parent_ids. set_parent_ids is however

        an easier API to use.

        :param revision_ids: The revision_ids to set as the parent ids of this

            working tree. Any of these may be ghosts.

        """

        with self.lock_tree_write():

            self._check_parents_for_ghosts(revision_ids,

                allow_leftmost_as_ghost=allow_leftmost_as_ghost)

            for revision_id in revision_ids:

                _mod_revision.check_not_reserved_id(revision_id)

            revision_ids = self._filter_parent_ids_by_ancestry(revision_ids)

            if len(revision_ids) > 0:

                self.set_last_revision(revision_ids[0])

            else:

                self.set_last_revision(_mod_revision.NULL_REVISION)

            self._set_merges_from_parent_ids(revision_ids)

    def set_pending_merges(self, rev_list):

        with self.lock_tree_write():

            parents = self.get_parent_ids()

            leftmost = parents[:1]

            new_parents = leftmost + rev_list

            self.set_parent_ids(new_parents)

    def set_merge_modified(self, modified_hashes):

        """Set the merge modified hashes."""

        raise NotImplementedError(self.set_merge_modified)

    def _sha_from_stat(self, path, stat_result):

        """Get a sha digest from the tree's stat cache.

        The default implementation assumes no stat cache is present.

        :param path: The path.

        :param stat_result: The stat result being looked up.

        """

        return None

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

                          merge_type=None, force=False):