/brz/remove-bazaar

# Copyright (C) 2005, 2006 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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).

"""

MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"

CONFLICT_HEADER_1 = "BZR conflict list format 1"

# TODO: Give the workingtree sole responsibility for the working inventory;

# remove the variable and references to it from the branch.  This may require

# updating the commit code so as to update the inventory within the working

# copy, and making sure there's only one WorkingTree for any directory on disk.

# At the moment they may alias the inventory and have old copies of it in

# memory.  (Now done? -- mbp 20060309)

from binascii import hexlify

import collections

from copy import deepcopy

from cStringIO import StringIO

import errno

import fnmatch

import os

import re

import stat

from time import time

import warnings

import bzrlib

from bzrlib import bzrdir, errors, ignores, osutils, urlutils

from bzrlib.atomicfile import AtomicFile

import bzrlib.branch

from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.errors import (BzrCheckError,

                           BzrError,

                           ConflictFormatError,

                           WeaveRevisionNotPresent,

                           NotBranchError,

                           NoSuchFile,

                           NotVersionedError,

                           MergeModifiedFormatError,

                           UnsupportedOperation,

                           )

from bzrlib.inventory import InventoryEntry, Inventory

from bzrlib.lockable_files import LockableFiles, TransportLock

from bzrlib.lockdir import LockDir

from bzrlib.merge import merge_inner, transform_tree

from bzrlib.osutils import (

                            abspath,

                            compact_date,

                            file_kind,

                            isdir,

                            getcwd,

                            pathjoin,

                            pumpfile,

                            safe_unicode,

                            splitpath,

                            rand_chars,

                            normpath,

                            realpath,

                            relpath,

                            rename,

                            supports_executable,

                            )

from bzrlib.progress import DummyProgress, ProgressPhase

from bzrlib.revision import NULL_REVISION

from bzrlib.rio import RioReader, rio_file, Stanza

from bzrlib.symbol_versioning import (deprecated_passed,

        deprecated_method,

        deprecated_function,

        DEPRECATED_PARAMETER,

        zero_eight,

        )

from bzrlib.trace import mutter, note

from bzrlib.transform import build_tree

from bzrlib.transport import get_transport

from bzrlib.transport.local import LocalTransport

from bzrlib.textui import show_status

import bzrlib.tree

import bzrlib.ui

import bzrlib.xml5

# the regex removes any weird characters; we don't escape them 

# but rather just pull them out

_gen_file_id_re = re.compile(r'[^\w.]')

_gen_id_suffix = None

_gen_id_serial = 0

def _next_id_suffix():

    """Create a new file id suffix that is reasonably unique.

    On the first call we combine the current time with 64 bits of randomness

    to give a highly probably globally unique number. Then each call in the same

    process adds 1 to a serial number we append to that unique value.

    """

    # XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather 

    # than having to move the id randomness out of the inner loop like this.

    # XXX TODO: for the global randomness this uses we should add the thread-id

    # before the serial #.

    global _gen_id_suffix, _gen_id_serial

    if _gen_id_suffix is None:

        _gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))

    _gen_id_serial += 1

    return _gen_id_suffix + str(_gen_id_serial)

def gen_file_id(name):

    """Return new file id for the basename 'name'.

    The uniqueness is supplied from _next_id_suffix.

    """

    # The real randomness is in the _next_id_suffix, the

    # rest of the identifier is just to be nice.

    # So we:

    # 1) Remove non-ascii word characters to keep the ids portable

    # 2) squash to lowercase, so the file id doesn't have to

    #    be escaped (case insensitive filesystems would bork for ids

    #    that only differred in case without escaping).

    # 3) truncate the filename to 20 chars. Long filenames also bork on some

    #    filesystems

    # 4) Removing starting '.' characters to prevent the file ids from

    #    being considered hidden.

    ascii_word_only = _gen_file_id_re.sub('', name.lower())

    short_no_dots = ascii_word_only.lstrip('.')[:20]

    return short_no_dots + _next_id_suffix()

def gen_root_id():

    """Return a new tree-root file id."""

    return gen_file_id('TREE_ROOT')

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.tree.Tree):

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

    """

    def __init__(self, basedir='.',

                 branch=DEPRECATED_PARAMETER,

                 _inventory=None,

                 _control_files=None,

                 _internal=False,

                 _format=None,

                 _bzrdir=None):

        """Construct a WorkingTree for basedir.

        If the branch is not supplied, it is opened automatically.

        If the branch is supplied, it must be the branch for this basedir.

        (branch.base is not cross checked, because for remote branches that

        would be meaningless).

        """

        self._format = _format

        self.bzrdir = _bzrdir

        if not _internal:

            # not created via open etc.

            warnings.warn("WorkingTree() is deprecated as of bzr version 0.8. "

                 "Please use bzrdir.open_workingtree or WorkingTree.open().",

                 DeprecationWarning,

                 stacklevel=2)

            wt = WorkingTree.open(basedir)

            self._branch = wt.branch

            self.basedir = wt.basedir

            self._control_files = wt._control_files

            self._hashcache = wt._hashcache

            self._set_inventory(wt._inventory)

            self._format = wt._format

            self.bzrdir = wt.bzrdir

        from bzrlib.hashcache import HashCache

        from bzrlib.trace import note, mutter

        assert isinstance(basedir, basestring), \

            "base directory %r is not a string" % basedir

        basedir = safe_unicode(basedir)

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

        if deprecated_passed(branch):

            if not _internal:

                warnings.warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."

                     " Please use bzrdir.open_workingtree() or"

                     " WorkingTree.open().",

                     DeprecationWarning,

                     stacklevel=2

                     )

            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.

            assert isinstance(_control_files, LockableFiles), \

                    "_control_files must be a LockableFiles, not %r" \

                    % _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

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

        cache_filename = self.bzrdir.get_workingtree_transport(None).local_abspath('stat-cache')

        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)

        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:

            self._set_inventory(self.read_working_inventory())

        else:

            self._set_inventory(_inventory)

    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 _set_inventory(self, inv):

        assert inv.root is not None

        self._inventory = inv

        self.path2id = self._inventory.path2id

    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.bzrdir.is_control_filename(filename)

    @staticmethod

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

        """Open an existing working tree at path.

        """

        if path is None:

            path = os.path.getcwdu()

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

    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 __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(None).

        """

        revision_id = self.last_revision()

        if revision_id is not None:

            try:

                xml = self.read_basis_inventory()

                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)

                inv.root.revision = revision_id

            except NoSuchFile:

                inv = None

            if inv is not None and inv.revision_id == revision_id:

                return bzrlib.tree.RevisionTree(self.branch.repository, inv,

                                                revision_id)

        # FIXME? RBC 20060403 should we cache the inventory here ?

        try:

            return self.branch.repository.revision_tree(revision_id)

        except errors.RevisionNotPresent:

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

            # occured. 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(None)

    @staticmethod

    @deprecated_method(zero_eight)

    def create(branch, directory):

        """Create a workingtree for branch at directory.

        If existing_directory already exists it must have a .bzr directory.

        If it does not exist, it will be created.

        This returns a new WorkingTree object for the new checkout.

        TODO FIXME RBC 20060124 when we have checkout formats in place this

        should accept an optional revisionid to checkout [and reject this if

        checking out into the same dir as a pre-checkout-aware branch format.]

        XXX: When BzrDir is present, these should be created through that 

        interface instead.

        """

        warnings.warn('delete WorkingTree.create', stacklevel=3)

        transport = get_transport(directory)

        if branch.bzrdir.root_transport.base == transport.base:

            # same dir 

            return branch.bzrdir.create_workingtree()

        # different directory, 

        # create a branch reference

        # and now a working tree.

        raise NotImplementedError

    @staticmethod

    @deprecated_method(zero_eight)

    def create_standalone(directory):

        """Create a checkout and a branch and a repo at directory.

        Directory must exist and be empty.

        please use BzrDir.create_standalone_workingtree

        """

        return bzrdir.BzrDir.create_standalone_workingtree(directory)

    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 relpath(self.basedir, path)

    def has_filename(self, filename):

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

    def get_file(self, file_id):

        return self.get_file_byname(self.id2path(file_id))

    def get_file_text(self, file_id):

        return self.get_file(file_id).read()

    def get_file_byname(self, filename):

        return file(self.abspath(filename), 'rb')

    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 = self.last_revision()

        if last_rev is None:

            parents = []

        else:

            parents = [last_rev]

        other_parents = self.pending_merges()

        return parents + other_parents

    def get_root_id(self):

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

        inv = self.read_working_inventory()

        return inv.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, basis=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 and difference between the source trees last revision

            and this one merged in.

        basis

            If not None, a closer copy of a tree which may have some files in

            common, and which file content should be preferentially copied from.

        """

        # assumes the target bzr dir format is compatible.

        result = self._format.initialize(to_bzrdir)

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

        if revision_id is None:

            transform_tree(tree, self)

        else:

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

            # user local changes)

            transform_tree(tree, self)

            tree.set_parent_ids([revision_id])

    @needs_write_lock

    def commit(self, message=None, revprops=None, *args, **kwargs):

        # avoid circular imports

        from bzrlib.commit import Commit

        if revprops is None:

            revprops = {}

        if not 'branch-nick' in revprops:

            revprops['branch-nick'] = self.branch.nick

        # args for wt.commit start at message from the Commit.commit method,

        # but with branch a kwarg now, passing in args as is results in the

        #message being used for the branch

        args = (DEPRECATED_PARAMETER, message, ) + args

        committed_id = Commit().commit( working_tree=self, revprops=revprops,

            *args, **kwargs)

        self._set_inventory(self.read_working_inventory())

        return committed_id

    def id2abspath(self, file_id):

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

    def has_id(self, file_id):

        # files that have been deleted are excluded

        inv = self._inventory

        if not inv.has_id(file_id):

            return False

        path = inv.id2path(file_id)

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

    def has_or_had_id(self, file_id):

        if file_id == self.inventory.root.file_id:

            return True

        return self.inventory.has_id(file_id)

    __contains__ = has_id

    def get_file_size(self, file_id):

        return os.path.getsize(self.id2abspath(file_id))

    @needs_read_lock

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

        if not path:

            path = self._inventory.id2path(file_id)

        return self._hashcache.get_sha1(path)

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

        if not path:

            path = self._inventory.id2path(file_id)

        return os.lstat(self.abspath(path)).st_mtime

    if not supports_executable():

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

            return self._inventory[file_id].executable

    else:

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

            if not path:

                path = self._inventory.id2path(file_id)

            mode = os.lstat(self.abspath(path)).st_mode

            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)

    @needs_write_lock

    def add(self, files, ids=None):

        """Make files versioned.

        Note that the command line normally calls smart_add instead,

        which can automatically recurse.

        This adds the files to the inventory, so that they will be

        recorded by the next commit.

        files

            List of paths to add, relative to the base of the tree.

        ids

            If set, use these instead of automatically generated ids.

            Must be the same length as the list of files, but may

            contain None for ids that are to be autogenerated.

        TODO: Perhaps have an option to add the ids even if the files do

              not (yet) exist.

        TODO: Perhaps callback with the ids and paths as they're added.

        """

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

        # should probably put it back with the previous ID.

        if isinstance(files, basestring):

            assert(ids is None or isinstance(ids, basestring))

            files = [files]

            if ids is not None:

                ids = [ids]

        if ids is None:

            ids = [None] * len(files)

        else:

            assert(len(ids) == len(files))

        inv = self.read_working_inventory()

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

            if self.is_control_filename(f):

                raise errors.ForbiddenControlFileError(filename=f)

            fp = splitpath(f)

            if len(fp) == 0:

                raise BzrError("cannot add top-level %r" % f)

            fullpath = normpath(self.abspath(f))

            try:

                kind = file_kind(fullpath)

            except OSError, e:

                if e.errno == errno.ENOENT:

                    raise NoSuchFile(fullpath)

            if not InventoryEntry.versionable_kind(kind):

                raise errors.BadFileKindError(filename=f, kind=kind)

            if file_id is None:

                inv.add_path(f, kind=kind)

            else:

                inv.add_path(f, kind=kind, file_id=file_id)

        self._write_inventory(inv)

    @needs_write_lock

    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.

        """

        self.set_parent_ids(self.get_parent_ids() + [revision_id],

            allow_leftmost_as_ghost=allow_leftmost_as_ghost)

    @needs_write_lock

    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.

        """

        self.set_parent_ids(self.get_parent_ids() + [parent_tuple[0]],

            allow_leftmost_as_ghost=allow_leftmost_as_ghost)

    @needs_write_lock

    def add_pending_merge(self, *revision_ids):

        # TODO: Perhaps should check at this point that the

        # history of the revision is actually present?

        p = self.pending_merges()

        existing_parents = self.get_parent_ids()