~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

WorkingTree.open(dir).

"""

 

 

from cStringIO import StringIO

import os

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,

    trace,

    transform,

    ui,

    views,

    xml5,

    xml7,

    )

from bzrlib.workingtree_4 import (

    WorkingTreeFormat4,

    WorkingTreeFormat5,

 

from bzrlib import symbol_versioning

from bzrlib.decorators import needs_read_lock, needs_write_lock

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,

from bzrlib.filters import filtered_input_file

from bzrlib.trace import mutter, note

from bzrlib.transport.local import LocalTransport

from bzrlib.rio import RioReader, rio_file, Stanza

 

 

MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"

CONFLICT_HEADER_1 = "BZR conflict list format 1"

 

ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT

        return ''

 

 

    """Working copy tree.

 

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

 

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

    not listed in the Inventory and vice versa.

    """

 

    # override this to set the strategy for storing views

        self._rules_searcher = None

        self.views = self._make_views()

 

    def _detect_case_handling(self):

        wt_trans = self.bzrdir.get_workingtree_transport(None)

        try:

        self._control_files.break_lock()

        self.branch.break_lock()

 

    def requires_rich_root(self):

        return self._format.requires_rich_root

 

        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.

 

                return True, None

            else:

                return True, tree

                                              list_current=list_current)

 

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

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

        return (file_obj, stat_value)

 

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

 

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

        path = self.abspath(filename)

        incorrectly attributed to CURRENT_REVISION (but after committing, the

        attribution will be correct).

        """

 

    def _get_ancestors(self, default_revision):

        ancestors = set([default_revision])

        else:

            parents = [last_rev]

        try:

        except errors.NoSuchFile:

            pass

        else:

                revision_id = l.rstrip('\n')

                parents.append(revision_id)

        return parents

 

    def get_file_size(self, file_id):

        """See Tree.get_file_size"""

        try:

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

        except OSError, e:

 

    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):

        file_id = self.path2id(path)

        return self._inventory[file_id].executable

 

    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):

            raise

        kind = _mapper(stat_result.st_mode)

        if kind == 'file':

        elif kind == 'directory':

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

            # reference.

        else:

            return (kind, None, None, None)

 

    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):

        """Common ghost checking functionality from set_parent_*.

 

 

    @needs_write_lock # because merge pulls data into the branch.

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

        """Merge from a branch into this working tree.

 

        :param branch: The branch to merge from.

            branch.last_revision().

        """

        from bzrlib.merge import Merger, Merge3Merger

        return conflicts

 

    @needs_read_lock

        tree_transport = self.bzrdir.root_transport.clone(sub_path)

        if tree_transport.base != branch_transport.base:

            tree_bzrdir = format.initialize_on_transport(tree_transport)

        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

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

        # jam 20060527 The kernel sized tree seems equivalent whether we

        # 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

 

                if f_ie:

                    c = 'V'

                elif self.is_ignored(fp[1:]):

                    c = 'I'

                else:

                    f_norm, can_access = osutils.normalized_filename(f)

                    if f == f_norm or not can_access:

                        # No change, so treat this file normally

                if fk != 'directory':

                    continue

 

            else:

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

                stack.pop()

 

    @needs_tree_write_lock

        """Rename files.

 

        to_dir must exist in the inventory.

 

        # check for deprecated use of signature

        if to_dir is None:

        # check destination directory

        if isinstance(from_paths, basestring):

            raise ValueError()

        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)

    @needs_write_lock

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

             change_reporter=None, possible_transports=None, local=False):

        source.lock_read()

        try:

            old_revision_info = self.branch.last_revision_info()

            basis_tree = self.basis_tree()

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

                                     local=local)

            new_revision_info = self.branch.last_revision_info()

            if new_revision_info != old_revision_info:

                repository = self.branch.repository

                basis_tree.lock_read()

                try:

                    new_basis_tree = self.branch.basis_tree()

                                new_basis_tree,

                                basis_tree,

                                this_tree=self,

                                change_reporter=change_reporter)

                finally:

                    basis_tree.unlock()

                # TODO - dedup parents list with things merged by pull ?

                # reuse the revisiontree we merged against to set the new

            return count

        finally:

            source.unlock()

 

    @needs_write_lock

    def put_file_bytes_non_atomic(self, file_id, bytes):

        r"""Check whether the filename matches an ignore pattern.

 

        Patterns containing '/' or '\' need to match the whole path;

 

        If the file is ignored, returns the pattern which caused it to

        be ignored, otherwise None.  So this can simply be used as a

        boolean if desired."""

        if getattr(self, '_ignoreglobster', None) is None:

        return self._ignoreglobster.match(filename)

 

    def kind(self, file_id):

            raise errors.ObjectNotLocked(self)

 

    def lock_read(self):

        if not self.is_locked():

            self._reset_data()

        self.branch.lock_read()

        try:

        except:

            self.branch.unlock()

            raise

 

    def lock_tree_write(self):

        if not self.is_locked():

            self._reset_data()

        self.branch.lock_read()

        try:

        except:

            self.branch.unlock()

            raise

 

    def lock_write(self):

        if not self.is_locked():

            self._reset_data()

        self.branch.lock_write()

        try:

        except:

            self.branch.unlock()

            raise

    def _reset_data(self):

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

        self._inventory_is_modified = False

        self._set_inventory(result, dirty=False)

 

    @needs_tree_write_lock

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

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

            if (not 'revision_id="' in firstline or

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

                xml = self._create_basis_xml_from_inventory(new_revision, inv)

            self._write_basis_inventory(xml)

        except (errors.NoSuchRevision, errors.RevisionNotPresent):

        # binary.

        if self._inventory_is_modified:

            raise errors.InventoryModified(self)

        self._set_inventory(result, dirty=False)

        return result

 

 

        inv_delta = []

 

        unknown_nested_files=set()

 

        def recurse_directory_to_add_files(directory):

            # Recurse directory and add all files

            # so we can check if they have changed.

                for relpath, basename, kind, lstat, fileid, kind in file_infos:

                    # Is it versioned or ignored?

                        # Add nested content for deletion.

                    else:

                        # should be treated as unknown.

 

        for filename in files:

            # Get file name into canonical form.

            abspath = self.abspath(filename)

            filename = self.relpath(abspath)

            if len(filename) > 0:

                recurse_directory_to_add_files(filename)

 

 

        if len(files) == 0:

            return # nothing to do

 

        # Bail out if we are going to delete files we shouldn't

        if not keep_files and not force:

 

 

        # Build inv_delta and delete files where applicable,

        # do this before any modifications to inventory.

                        new_status = 'I'

                    else:

                        new_status = '?'

                # Unversion file

                inv_delta.append((f, None, fid, None))

                message = "removed %s" % (f,)

                        len(os.listdir(abs_path)) > 0):

                        if force:

                            osutils.rmtree(abs_path)

                        else:

                    else:

                elif message is not None:

                    # Only care if we haven't done anything yet.

                    message = "%s does not exist." % (f,)

 

    @needs_tree_write_lock

    def revert(self, filenames=None, old_tree=None, backups=True,

        from bzrlib.conflicts import resolve

        if filenames == []:

            filenames = None

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