~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 Canonical Ltd

    controldir,

    filters as _mod_filters,

    rio as _mod_rio,

    transport,

from bzrlib.lock import LogicalLockResult

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

class WorkingTree(bzrlib.mutabletree.MutableTree,

    controldir.ControlComponent):

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

        (as opposed to a URL).

        self._control_files = _control_files

    @property

    def user_transport(self):

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

 

            wt_trans.stat(self._format.case_sensitive_filename)

    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

        t = transport.get_transport(location)

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

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

        raise NotImplementedError(self.all_file_ids)

                           _fstat=osutils.fstat):

            file_obj = _mod_filters.filtered_input_file(file_obj, filters)

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

        try:

            return my_file.read()

        finally:

            my_file.close()

            return _mod_filters.filtered_input_file(f, filters)

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

            for l in osutils.split_lines(merges_bytes):

        raise NotImplementedError(self.get_root_id)

    def _check_for_tree_references(self, iterator):

        """See if directories have become tree-references."""

        blocked_parent_ids = set()

        for path, ie in iterator:

            if ie.parent_id in blocked_parent_ids:

                # This entry was pruned because one of its parents became a

                # TreeReference. If this is a directory, mark it as blocked.

                if ie.kind == 'directory':

                    blocked_parent_ids.add(ie.file_id)

                continue

            if ie.kind == 'directory' and self._directory_is_tree_reference(path):

                # This InventoryDirectory needs to be a TreeReference

                ie = inventory.TreeReference(ie.file_id, ie.name, ie.parent_id)

                blocked_parent_ids.add(ie.file_id)

            yield path, ie

 

    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):

        """See Tree.iter_entries_by_dir()"""

        # The only trick here is that if we supports_tree_reference then we

        # need to detect if a directory becomes a tree-reference.

        iterator = super(WorkingTree, self).iter_entries_by_dir(

                specific_file_ids=specific_file_ids,

                yield_parents=yield_parents)

        if not self.supports_tree_reference():

            return iterator

        else:

            return self._check_for_tree_references(iterator)

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

        # canonical size

            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.

            return self._file_content_summary(path, stat_result)

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

 

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

                yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),

                    hash=hash)

        my_file = _mod_rio.rio_file(stanzas, header)

                          merge_type=None, force=False):

        merger = Merger(self.branch, this_tree=self)

        # check that there are no local alterations

        if not force and self.has_changes():

            raise errors.UncommittedChanges(self)

        if to_revision is None:

            to_revision = _mod_revision.ensure_null(branch.last_revision())

        merger.other_rev_id = to_revision

        if _mod_revision.is_null(merger.other_rev_id):

            raise errors.NoCommits(branch)

        self.branch.fetch(branch, last_revision=merger.other_rev_id)

        merger.other_basis = merger.other_rev_id

        merger.other_tree = self.branch.repository.revision_tree(

            merger.other_rev_id)

        merger.other_branch = branch

        if from_revision is None:

            merger.find_base()

        else:

            merger.set_base_revision(from_revision, branch)

        if merger.base_rev_id == merger.other_rev_id:

            raise errors.PointlessMerge

        merger.backup_files = False

        if merge_type is None:

            merger.merge_type = Merge3Merger

        else:

            merger.merge_type = merge_type

        merger.set_interesting_files(None)

        merger.show_base = False

        merger.reprocess = False

        conflicts = merger.do_merge()

        merger.set_pending()

        raise NotImplementedError(self.merge_modified)

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

        if path is not None:

            abspath = self.abspath(path)

        else:

            abspath = self.id2abspath(file_id)

        raise NotImplementedError(self.subsume)

        raise NotImplementedError(self.extract)