~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 Canonical Ltd.

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

import string

    cleanup,

    cmdline,

    controldir,

    views,

 

from bzrlib.workingtree import WorkingTree

from bzrlib.i18n import gettext

from bzrlib.registry import (

    Registry,

    )

from bzrlib.trace import mutter, note, warning

 

 

class AtTemplate(string.Template):

    """Templating class that uses @ instead of $."""

 

    delimiter = '@'

 

                      fromfile=old_filename.encode(path_encoding, 'replace'),

                      tofile=new_filename.encode(path_encoding, 'replace'),

        if sys.platform == 'win32':

            # Popen doesn't do the proper encoding for external commands

            # Since we are dealing with an ANSI api, use mbcs encoding

            old_filename = old_filename.encode('mbcs')

            new_filename = new_filename.encode('mbcs')

 

 

 

            raise errors.BzrError('external diff failed with %s; command: %r'

def get_trees_and_branches_to_diff_locked(

    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):

    :param add_cleanup:

        a callable like Command.add_cleanup.  get_trees_and_branches_to_diff

        will register cleanups that must be run to unlock the trees, etc.

    :param apply_view:

        if True and a view is set, apply the view or check that the paths

        are within it

        a tuple of (old_tree, new_tree, old_branch, new_branch,

        specific_files, extra_trees) where extra_trees is a sequence of

        additional trees to search in for file-ids.  The trees and branches

        will be read-locked until the cleanups registered via the add_cleanup

        param are run.

    def lock_tree_or_branch(wt, br):

        if wt is not None:

            wt.lock_read()

            add_cleanup(wt.unlock)

        elif br is not None:

            br.lock_read()

            add_cleanup(br.unlock)

 

        controldir.ControlDir.open_containing_tree_or_branch(old_url)

    lock_tree_or_branch(working_tree, branch)

        if working_tree is not None and apply_view:

            views.check_path_in_view(working_tree, relpath)

    old_branch = branch

            controldir.ControlDir.open_containing_tree_or_branch(new_url)

        lock_tree_or_branch(working_tree, branch)

            if working_tree is not None and apply_view:

                views.check_path_in_view(working_tree, relpath)

    new_branch = branch

        other_paths = working_tree.safe_relpath_files(

            other_paths,

            apply_view=apply_view)

        if (working_tree is not None and working_tree.supports_views()

            and apply_view):

            view_files = working_tree.views.lookup_view()

            if view_files:

                specific_files = view_files

                view_str = views.view_display_str(view_files)

                note(gettext("*** Ignoring files outside view. View is %s") % view_str)

    return (old_tree, new_tree, old_branch, new_branch,

            specific_files, extra_trees)

    return spec.as_tree(branch)

                    using=None,

                    format_cls=None):

    :param to_file: The output stream.

    :param specific_files: Include only changes to these files - None for all

        changes.

    :param external_diff_options: If set, use an external GNU diff and pass 

        these options.

    :param extra_trees: If set, more Trees to use for looking up file ids

    :param path_encoding: If set, the path will be encoded as specified, 

        otherwise is supposed to be utf8

    :param format_cls: Formatter class (DiffTree subclass)

    if format_cls is None:

        format_cls = DiffTree

            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,

                                                   path_encoding,

                                                   external_diff_options,

                                                   old_label, new_label, using)

    try:

        mtime = tree.get_file_mtime(file_id, path)

    except errors.FileTimestampUnavailable:

        mtime = 0

def get_executable_change(old_is_x, new_is_x):

    descr = { True:"+x", False:"-x", None:"??" }

    if old_is_x != new_is_x:

        return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]

        return []

        return self.diff_text(from_file_id, to_file_id, from_label, to_label,

            old_path, new_path)

    def diff_text(self, from_file_id, to_file_id, from_label, to_label,

        from_path=None, to_path=None):

        :param from_path: The path in the from tree or None if unknown.

        :param to_path: The path in the to tree or None if unknown.

        def _get_text(tree, file_id, path):

                return tree.get_file_lines(file_id, path)

            from_text = _get_text(self.old_tree, from_file_id, from_path)

            to_text = _get_text(self.new_tree, to_file_id, to_path)

                             self.to_file, path_encoding=self.path_encoding)

                  (from_label, to_label)).encode(self.path_encoding,'replace'))

        self._root = osutils.mkdtemp(prefix='bzr-diff-')

        command_template = cmdline.split(command_string)

        if '@' not in command_string:

            command_template.extend(['@old_path', '@new_path'])

    def make_from_diff_tree(klass, command_string, external_diff_options=None):

            full_command_string = [command_string]

            if external_diff_options is not None:

                full_command_string += ' ' + external_diff_options

            return klass.from_string(full_command_string, diff_tree.old_tree,

        command = [AtTemplate(t).substitute(my_map) for t in

                   self.command_template]

        if sys.platform == 'win32': # Popen doesn't accept unicode on win32

            command_encoded = []

            for c in command:

                if isinstance(c, unicode):

                    command_encoded.append(c.encode('mbcs'))

                else:

                    command_encoded.append(c)

            return command_encoded

        else:

            return command

        if (getattr(tree, 'abspath', None) is None

            or not osutils.host_os_dereferences_symlinks()):

    @staticmethod

    def _fenc():

        """Returns safe encoding for passing file path to diff tool"""

        if sys.platform == 'win32':

            return 'mbcs'

        else:

            # Don't fallback to 'utf-8' because subprocess may not be able to

            # handle utf-8 correctly when locale is not utf-8.

            return sys.getfilesystemencoding() or 'ascii'

 

    def _is_safepath(self, path):

        """Return true if `path` may be able to pass to subprocess."""

        fenc = self._fenc()

        try:

            return path == path.encode(fenc).decode(fenc)

        except UnicodeError:

            return False

 

    def _safe_filename(self, prefix, relpath):

        """Replace unsafe character in `relpath` then join `self._root`,

        `prefix` and `relpath`."""

        fenc = self._fenc()

        # encoded_str.replace('?', '_') may break multibyte char.

        # So we should encode, decode, then replace(u'?', u'_')

        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')

        relpath_tmp = relpath_tmp.replace(u'?', u'_')

        return osutils.pathjoin(self._root, prefix, relpath_tmp)

 

    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,

                    allow_write=False):

        if not force_temp and isinstance(tree, WorkingTree):

            full_path = tree.abspath(tree.id2path(file_id))

            if self._is_safepath(full_path):

                return full_path

 

        full_path = self._safe_filename(prefix, relpath)

        if not force_temp and self._try_symlink_root(tree, prefix):

        try:

            mtime = tree.get_file_mtime(file_id)

        except errors.FileTimestampUnavailable:

            pass

        else:

            os.utime(full_path, (mtime, mtime))

        if not allow_write:

            osutils.make_readonly(full_path)

    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,

                       allow_write_new=False):

                                         old_path, force_temp)

                                         new_path, force_temp,

                                         allow_write=allow_write_new)

        try:

            osutils.rmtree(self._root)

        except OSError, e:

            if e.errno != errno.ENOENT:

                mutter("The temporary directory \"%s\" was not "

                        "cleanly removed: %s." % (self._root, e))

        (old_disk_path, new_disk_path) = self._prepare_files(

                                                file_id, old_path, new_path)

        self._execute(old_disk_path, new_disk_path)

 

    def edit_file(self, file_id):

        """Use this tool to edit a file.

 

        A temporary copy will be edited, and the new contents will be

        returned.

 

        :param file_id: The id of the file to edit.

        :return: The new contents of the file.

        """

        old_path = self.old_tree.id2path(file_id)

        new_path = self.new_tree.id2path(file_id)

        old_abs_path, new_abs_path = self._prepare_files(

                                            file_id, old_path, new_path,

                                            allow_write_new=True,

                                            force_temp=True)

        command = self._get_command(old_abs_path, new_abs_path)

        subprocess.call(command, cwd=self._root)

        new_file = open(new_abs_path, 'rb')

        try:

            return new_file.read()

        finally:

            new_file.close()

 

            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]

            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):

                """:param path_encoding: not used but required

                        to match the signature of internal_diff.

                """

        :param specific_files: the specific files to compare (recursive)

            # The root does not get diffed, and items with no known kind (that

            # is, missing) in both trees are skipped as well.

            if parent == (None, None) or kind == (None, None):

 

            properties_changed = []

            properties_changed.extend(get_executable_change(executable[0], executable[1]))

 

            if properties_changed:

                prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)

            else:

                prop_str = ""

 

                self._diff(file_id, oldpath, newpath, kind[0], kind[1])

        self._diff(file_id, old_path, new_path, old_kind, new_kind)