/brz/remove-bazaar

# Copyright (C) 2005-2014 Canonical Ltd.

#

# 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

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

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

from __future__ import absolute_import

import difflib

import os

import re

import string

import sys

from .lazy_import import lazy_import

lazy_import(globals(), """

import errno

import subprocess

import tempfile

from breezy import (

    cmdline,

    controldir,

    errors,

    osutils,

    patiencediff,

    textfile,

    timestamp,

    views,

    )

from breezy.workingtree import WorkingTree

from breezy.i18n import gettext

""")

from .registry import (

    Registry,

    )

from .sixish import text_type

from .trace import mutter, note, warning

from .tree import FileTimestampUnavailable

DEFAULT_CONTEXT_AMOUNT = 3

class AtTemplate(string.Template):

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

    delimiter = '@'

# TODO: Rather than building a changeset object, we should probably

# invoke callbacks on an object.  That object can either accumulate a

# list, write them out directly, etc etc.

class _PrematchedMatcher(difflib.SequenceMatcher):

    """Allow SequenceMatcher operations to use predetermined blocks"""

    def __init__(self, matching_blocks):

        difflib.SequenceMatcher(self, None, None)

        self.matching_blocks = matching_blocks

        self.opcodes = None

def internal_diff(old_label, oldlines, new_label, newlines, to_file,

                  allow_binary=False, sequence_matcher=None,

                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):

    # FIXME: difflib is wrong if there is no trailing newline.

    # The syntax used by patch seems to be "\ No newline at

    # end of file" following the last diff line from that

    # file.  This is not trivial to insert into the

    # unified_diff output and it might be better to just fix

    # or replace that function.

    # In the meantime we at least make sure the patch isn't

    # mangled.

    if allow_binary is False:

        textfile.check_text_lines(oldlines)

        textfile.check_text_lines(newlines)

    if sequence_matcher is None:

        sequence_matcher = patiencediff.PatienceSequenceMatcher

    ud = patiencediff.unified_diff_bytes(oldlines, newlines,

                                         fromfile=old_label.encode(

                                             path_encoding, 'replace'),

                                         tofile=new_label.encode(

                                             path_encoding, 'replace'),

                                         n=context_lines, sequencematcher=sequence_matcher)

    ud = list(ud)

    if len(ud) == 0:  # Identical contents, nothing to do

        return

    # work-around for difflib being too smart for its own good

    # if /dev/null is "1,0", patch won't recognize it as /dev/null

    if not oldlines:

        ud[2] = ud[2].replace(b'-1,0', b'-0,0')

    elif not newlines:

        ud[2] = ud[2].replace(b'+1,0', b'+0,0')

    for line in ud:

        to_file.write(line)

        if not line.endswith(b'\n'):

            to_file.write(b"\n\\ No newline at end of file\n")

    to_file.write(b'\n')

def _spawn_external_diff(diffcmd, capture_errors=True):

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

    :param diffcmd: The command list to spawn

    :param capture_errors: Capture stderr as well as setting LANG=C

        and LC_ALL=C. This lets us read and understand the output of diff,

        and respond to any errors.

    :return: A Popen object.

    """

    if capture_errors:

        # construct minimal environment

        env = {}

        path = os.environ.get('PATH')

        if path is not None:

            env['PATH'] = path

        env['LANGUAGE'] = 'C'   # on win32 only LANGUAGE has effect

        env['LANG'] = 'C'

        env['LC_ALL'] = 'C'

        stderr = subprocess.PIPE

    else:

        env = None

        stderr = None

    try:

        pipe = subprocess.Popen(diffcmd,

                                stdin=subprocess.PIPE,

                                stdout=subprocess.PIPE,

                                stderr=stderr,

                                env=env)

    except OSError as e:

        if e.errno == errno.ENOENT:

            raise errors.NoDiff(str(e))

        raise

    return pipe

# 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

def external_diff(old_label, oldlines, new_label, newlines, to_file,

                  diff_opts):

    """Display a diff by calling out to the external diff program."""

    # make sure our own output is properly ordered before the diff

    to_file.flush()

    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='brz-diff-old-')

    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='brz-diff-new-')

    oldtmpf = os.fdopen(oldtmp_fd, 'wb')

    newtmpf = os.fdopen(newtmp_fd, 'wb')

    try:

        # TODO: perhaps a special case for comparing to or from the empty

        # sequence; can just use /dev/null on Unix

        # TODO: if either of the files being compared already exists as a

        # regular named file (e.g. in the working directory) then we can

        # compare directly to that, rather than copying it.

        oldtmpf.writelines(oldlines)

        newtmpf.writelines(newlines)

        oldtmpf.close()

        newtmpf.close()

        if not diff_opts:

            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_label = old_label.encode('mbcs')

            new_label = new_label.encode('mbcs')

        diffcmd = ['diff',

                   '--label', old_label,

                   old_abspath,

                   '--label', new_label,

                   new_abspath,

                   '--binary',

                   ]

        diff_opts = default_style_unified(diff_opts)

        if diff_opts:

            diffcmd.extend(diff_opts)

        pipe = _spawn_external_diff(diffcmd, capture_errors=True)

        out, err = pipe.communicate()

        rc = pipe.returncode

        # internal_diff() adds a trailing newline, add one here for consistency

        out += b'\n'

        if rc == 2:

            # 'diff' gives retcode == 2 for all sorts of errors

            # one of those is 'Binary files differ'.

            # Bad options could also be the problem.

            # 'Binary files' is not a real error, so we suppress that error.

            lang_c_out = out

            # Since we got here, we want to make sure to give an i18n error

            pipe = _spawn_external_diff(diffcmd, capture_errors=False)

            out, err = pipe.communicate()

            # Write out the new i18n diff response

            to_file.write(out + b'\n')

            if pipe.returncode != 2:

                raise errors.BzrError(

                    'external diff failed with exit code 2'

                    ' when run with LANG=C and LC_ALL=C,'

                    ' but not when run natively: %r' % (diffcmd,))

            first_line = lang_c_out.split(b'\n', 1)[0]

            # Starting with diffutils 2.8.4 the word "binary" was dropped.

            m = re.match(b'^(binary )?files.*differ$', first_line, re.I)

            if m is None:

                raise errors.BzrError('external diff failed with exit code 2;'

                                      ' command: %r' % (diffcmd,))

            else:

                # Binary files differ, just return

                return

        # If we got to here, we haven't written out the output of diff

        # do so now

        to_file.write(out)

        if rc not in (0, 1):

            # returns 1 if files differ; that's OK

            if rc < 0:

                msg = 'signal %d' % (-rc)

            else:

                msg = 'exit code %d' % rc

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

                                  % (msg, diffcmd))

    finally:

        oldtmpf.close()                 # and delete

        newtmpf.close()

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

    """Get the trees and specific files to diff given a list of paths.

    This method works out the trees to be diff'ed and the files of

    interest within those trees.

    :param path_list:

        the list of arguments passed to the diff command

    :param revision_specs:

        Zero, one or two RevisionSpecs from the diff command line,

        saying what revisions to compare.

    :param old_url:

        The url of the old branch or tree. If None, the tree to use is

        taken from the first path, if any, or the current working tree.

    :param new_url:

        The url of the new branch or tree. If None, the tree to use is

        taken from the first path, if any, or the current working tree.

    :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

    :returns:

        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.

    """

    # Get the old and new revision specs

    old_revision_spec = None

    new_revision_spec = None

    if revision_specs is not None:

        if len(revision_specs) > 0:

            old_revision_spec = revision_specs[0]

            if old_url is None:

                old_url = old_revision_spec.get_branch()

        if len(revision_specs) > 1:

            new_revision_spec = revision_specs[1]

            if new_url is None:

                new_url = new_revision_spec.get_branch()

    other_paths = []

    make_paths_wt_relative = True

    consider_relpath = True

    if path_list is None or len(path_list) == 0:

        # If no path is given, the current working tree is used

        default_location = u'.'

        consider_relpath = False

    elif old_url is not None and new_url is not None:

        other_paths = path_list

        make_paths_wt_relative = False

    else:

        default_location = path_list[0]

        other_paths = path_list[1:]

    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)

    # Get the old location

    specific_files = []

    if old_url is None:

        old_url = default_location

    working_tree, branch, relpath = \

        controldir.ControlDir.open_containing_tree_or_branch(old_url)

    lock_tree_or_branch(working_tree, branch)

    if consider_relpath and relpath != '':

        if working_tree is not None and apply_view:

            views.check_path_in_view(working_tree, relpath)

        specific_files.append(relpath)

    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)

    old_branch = branch

    # Get the new location

    if new_url is None:

        new_url = default_location

    if new_url != old_url:

        working_tree, branch, relpath = \

            controldir.ControlDir.open_containing_tree_or_branch(new_url)

        lock_tree_or_branch(working_tree, branch)

        if consider_relpath and relpath != '':

            if working_tree is not None and apply_view:

                views.check_path_in_view(working_tree, relpath)

            specific_files.append(relpath)

    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,

                                 basis_is_default=working_tree is None)

    new_branch = branch

    # Get the specific files (all files is None, no files is [])

    if make_paths_wt_relative and working_tree is not None:

        other_paths = working_tree.safe_relpath_files(

            other_paths,

            apply_view=apply_view)

    specific_files.extend(other_paths)

    if len(specific_files) == 0:

        specific_files = None

        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)

    # Get extra trees that ought to be searched for file-ids

    extra_trees = None

    if working_tree is not None and working_tree not in (old_tree, new_tree):

        extra_trees = (working_tree,)

    return (old_tree, new_tree, old_branch, new_branch,

            specific_files, extra_trees)

def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):

    if branch is None and tree is not None:

        branch = tree.branch

    if spec is None or spec.spec is None:

        if basis_is_default:

            if tree is not None:

                return tree.basis_tree()

            else:

                return branch.basis_tree()

        else:

            return tree

    return spec.as_tree(branch)

def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,

                    external_diff_options=None,

                    old_label='a/', new_label='b/',

                    extra_trees=None,

                    path_encoding='utf8',

                    using=None,

                    format_cls=None,

                    context=DEFAULT_CONTEXT_AMOUNT):

    """Show in text form the changes from one tree to another.

    :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

    with old_tree.lock_read():

        if extra_trees is not None:

            for tree in extra_trees:

                tree.lock_read()

        new_tree.lock_read()

        try:

            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)

            return differ.show_diff(specific_files, extra_trees)

        finally:

            new_tree.unlock()

            if extra_trees is not None:

                for tree in extra_trees:

                    tree.unlock()

def _patch_header_date(tree, file_id, path):

    """Returns a timestamp suitable for use in a patch header."""

    try:

        mtime = tree.get_file_mtime(path)

    except FileTimestampUnavailable:

        mtime = 0

    return timestamp.format_patch_date(mtime)

def get_executable_change(old_is_x, new_is_x):

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

    if old_is_x != new_is_x:

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

    else:

        return []

class DiffPath(object):

    """Base type for command object that compare files"""

    # The type or contents of the file were unsuitable for diffing

    CANNOT_DIFF = 'CANNOT_DIFF'

    # The file has changed in a semantic way

    CHANGED = 'CHANGED'

    # The file content may have changed, but there is no semantic change

    UNCHANGED = 'UNCHANGED'

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

        """Constructor.

        :param old_tree: The tree to show as the old tree in the comparison

        :param new_tree: The tree to show as new in the comparison

        :param to_file: The file to write comparison data to

        :param path_encoding: The character encoding to write paths in

        """

        self.old_tree = old_tree

        self.new_tree = new_tree

        self.to_file = to_file

        self.path_encoding = path_encoding

    def finish(self):

        pass

    @classmethod

    def from_diff_tree(klass, diff_tree):

        return klass(diff_tree.old_tree, diff_tree.new_tree,

                     diff_tree.to_file, diff_tree.path_encoding)

    @staticmethod

    def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):

        for file_differ in differs:

            result = file_differ.diff(file_id, old_path, new_path, old_kind,

                                      new_kind)

            if result is not DiffPath.CANNOT_DIFF:

                return result

        else:

            return DiffPath.CANNOT_DIFF

class DiffKindChange(object):

    """Special differ for file kind changes.

    Represents kind change as deletion + creation.  Uses the other differs

    to do this.

    """

    def __init__(self, differs):

        self.differs = differs

    def finish(self):

        pass

    @classmethod

    def from_diff_tree(klass, diff_tree):

        return klass(diff_tree.differs)

    def diff(self, file_id, old_path, new_path, old_kind, new_kind):

        """Perform comparison

        :param file_id: The file_id of the file to compare

        :param old_path: Path of the file in the old tree

        :param new_path: Path of the file in the new tree

        :param old_kind: Old file-kind of the file

        :param new_kind: New file-kind of the file

        """

        if None in (old_kind, new_kind):

            return DiffPath.CANNOT_DIFF

        result = DiffPath._diff_many(self.differs, file_id, old_path,

                                     new_path, old_kind, None)

        if result is DiffPath.CANNOT_DIFF:

            return result

        return DiffPath._diff_many(self.differs, file_id, old_path, new_path,

                                   None, new_kind)

class DiffDirectory(DiffPath):

    def diff(self, file_id, old_path, new_path, old_kind, new_kind):

        """Perform comparison between two directories.  (dummy)

        """

        if 'directory' not in (old_kind, new_kind):

            return self.CANNOT_DIFF

        if old_kind not in ('directory', None):

            return self.CANNOT_DIFF

        if new_kind not in ('directory', None):

            return self.CANNOT_DIFF

        return self.CHANGED

class DiffSymlink(DiffPath):

    def diff(self, file_id, old_path, new_path, old_kind, new_kind):

        """Perform comparison between two symlinks

        :param file_id: The file_id of the file to compare

        :param old_path: Path of the file in the old tree

        :param new_path: Path of the file in the new tree

        :param old_kind: Old file-kind of the file

        :param new_kind: New file-kind of the file

        """

        if 'symlink' not in (old_kind, new_kind):

            return self.CANNOT_DIFF

        if old_kind == 'symlink':

            old_target = self.old_tree.get_symlink_target(old_path)

        elif old_kind is None:

            old_target = None

        else:

            return self.CANNOT_DIFF

        if new_kind == 'symlink':

            new_target = self.new_tree.get_symlink_target(new_path)

        elif new_kind is None:

            new_target = None

        else:

            return self.CANNOT_DIFF

        return self.diff_symlink(old_target, new_target)

    def diff_symlink(self, old_target, new_target):

        if old_target is None:

            self.to_file.write(b'=== target is \'%s\'\n' %

                               new_target.encode(self.path_encoding, 'replace'))

        elif new_target is None:

            self.to_file.write(b'=== target was \'%s\'\n' %

                               old_target.encode(self.path_encoding, 'replace'))

        else:

            self.to_file.write(b'=== target changed \'%s\' => \'%s\'\n' %

                               (old_target.encode(self.path_encoding, 'replace'),

                                new_target.encode(self.path_encoding, 'replace')))

        return self.CHANGED

class DiffText(DiffPath):

    # GNU Patch uses the epoch date to detect files that are being added

    # or removed in a diff.

    EPOCH_DATE = '1970-01-01 00:00:00 +0000'

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

        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)

        self.text_differ = text_differ

        self.old_label = old_label

        self.new_label = new_label

        self.path_encoding = path_encoding

        self.context_lines = context_lines

    def diff(self, file_id, old_path, new_path, old_kind, new_kind):

        """Compare two files in unified diff format

        :param file_id: The file_id of the file to compare

        :param old_path: Path of the file in the old tree

        :param new_path: Path of the file in the new tree

        :param old_kind: Old file-kind of the file

        :param new_kind: New file-kind of the file