~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2014 Canonical Ltd.

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

 

from __future__ import absolute_import

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

 

DEFAULT_CONTEXT_AMOUNT = 3

 

class AtTemplate(string.Template):

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

 

    delimiter = '@'

                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):

 

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

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

                      n=context_lines, sequencematcher=sequence_matcher)

    """Spawn the external diff process, and return the child handle.

# diff style options as of GNU diff v3.2

style_option_list = ['-c', '-C', '--context',

                     '-e', '--ed',

                     '-f', '--forward-ed',

                     '-q', '--brief',

                     '--normal',

                     '-n', '--rcs',

                     '-u', '-U', '--unified',

                     '-y', '--side-by-side',

                     '-D', '--ifdef']

 

def default_style_unified(diff_opts):

    """Default to unified diff style if alternative not specified in diff_opts.

 

        diff only allows one style to be specified; they don't override.

        Note that some of these take optargs, and the optargs can be

        directly appended to the options.

        This is only an approximate parser; it doesn't properly understand

        the grammar.

 

    :param diff_opts: List of options for external (GNU) diff.

    :return: List of options with default style=='unified'.

    """

    for s in style_option_list:

        for j in diff_opts:

            if j.startswith(s):

                break

        else:

            continue

        break

    else:

        diff_opts.append('-u')

    return diff_opts

 

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

        diff_opts = default_style_unified(diff_opts)

 

 

 

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

                                  % (msg, diffcmd))

 

        def cleanup(path):

            # Warn in case the file couldn't be deleted (in case windows still

            # holds the file open, but not if the files have already been

            # deleted)

            try:

                os.remove(path)

            except OSError, e:

                if e.errno not in (errno.ENOENT,):

                    warning('Failed to delete temporary file: %s %s', path, e)

 

        cleanup(old_abspath)

        cleanup(new_abspath)

 

 

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,

                    context=DEFAULT_CONTEXT_AMOUNT):

    :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 context is None:

        context = DEFAULT_CONTEXT_AMOUNT

    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,

                                                   context_lines=context)

    try:

        mtime = tree.get_file_mtime(file_id, path)

    except errors.FileTimestampUnavailable:

        mtime = 0

    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8', 

                 old_label='', new_label='', text_differ=internal_diff, 

                 context_lines=DEFAULT_CONTEXT_AMOUNT):

        self.context_lines = context_lines

        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,

                             context_lines=self.context_lines)

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

        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

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

                           new_label, using, context_lines):