~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,

    )

import bzrlib.branch

from bzrlib.transport import get_transport

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

        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

 

 

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

        _fstat=os.fstat):

        if path is None:

            path = self.id2path(file_id)

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

        stat_value = _fstat(file_obj.fileno())

            filters = self._content_filter_stack(path)

            file_obj = filtered_input_file(file_obj, filters)

        return (file_obj, stat_value)

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

        path = self.abspath(filename)

        f = file(path, 'rb')

            filters = self._content_filter_stack(filename)

            return filtered_input_file(f, filters)

        else:

        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.

                kind = 'tree-reference'

            return kind, None, None, None

        elif kind == 'symlink':

        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

        return file_id

 

    def get_symlink_target(self, file_id):

 

    @needs_write_lock

    def subsume(self, other_tree):

        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]

 

                if fk != 'directory':

                    continue

 

            else:

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

                stack.pop()

        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,

        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,

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

 

            fl = []

            for subf in os.listdir(dirabs):

                    continue

                if subf not in dir_entry.children:

                    try:

        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

 

 

        new_files=set()

        unknown_nested_files=set()

 

        def recurse_directory_to_add_files(directory):

            # Recurse directory and add all files

                        new_status = 'I'

                    else:

                        new_status = '?'

                # Unversion file

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

                message = "removed %s" % (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())

        """

        raise NotImplementedError(self.unlock)

 

        """Update a working tree along its branch.

 

        This will update the branch if its bound too, which means we have

        - Merge current state -> basis tree of the master w.r.t. the old tree

          basis.

        - Do a 'normal' merge of the old branch basis if it is relevant.

        """

        if self.branch.get_bound_location() is not None:

            self.lock_write()

        else:

            self.lock_tree_write()

            update_branch = False

            if update_branch:

                old_tip = self.branch.update(possible_transports)

            else:

        finally:

            self.unlock()

 

    @needs_tree_write_lock

        """Update a tree to the master branch.

 

        :param old_tip: if supplied, the previous tip revision the branch,

        # We MUST save it even if an error occurs, because otherwise the users

        # local work is unreferenced and will appear to have been lost.

        #

        try:

            last_rev = self.get_parent_ids()[0]

        except IndexError:

            last_rev = _mod_revision.NULL_REVISION

            basis = self.basis_tree()

            basis.lock_read()

            try:

                    self.flush()

            finally:

                basis.unlock()

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

            # reuse the tree we've updated to to set the basis:

            merges = self.get_parent_ids()[1:]

            # Ideally we ask the tree for the trees here, that way the working

            # tree can decide whether to give us the entire tree or give us a

            for parent in merges:

                parent_trees.append(

                    (parent, self.branch.repository.revision_tree(parent)))

                parent_trees.append(

                    (old_tip, self.branch.repository.revision_tree(old_tip)))

            self.set_parent_trees(parent_trees)

            last_rev = parent_trees[0][0]

 

    def _write_hashcache_if_dirty(self):

        """Write out the hashcache if it is dirty."""

                    bzrdir_loc = bisect_left(cur_disk_dir_content,

                        ('.bzr', '.bzr'))

                    if (bzrdir_loc < len(cur_disk_dir_content)

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

        """

        return

 

    def _get_rules_searcher(self, default_searcher):

        """See Tree._get_rules_searcher."""

        if self._rules_searcher is None:

        if self._inventory is None:

            self.read_working_inventory()

 

    def lock_tree_write(self):

        """See WorkingTree.lock_tree_write().

 

        In Format2 WorkingTrees we have a single lock for the branch and tree

        so lock_tree_write() degrades to lock_write().

        """

        self.branch.lock_write()

        try:

        except:

            self.branch.unlock()

            raise

 

    def _change_last_revision(self, revision_id):