# Copyright (c) 2009, Google Inc. All rights reserved.

# Copyright (c) 2009 Apple Inc. All rights reserved.

# 

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are

# met:

# 

#     * Redistributions of source code must retain the above copyright

# notice, this list of conditions and the following disclaimer.

#     * Redistributions in binary form must reproduce the above

# copyright notice, this list of conditions and the following disclaimer

# in the documentation and/or other materials provided with the

# distribution.

#     * Neither the name of Google Inc. nor the names of its

# contributors may be used to endorse or promote products derived from

# this software without specific prior written permission.

# 

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#

# Python module for interacting with an SCM system (like SVN or Git)

import os

import re

import sys

import shutil

from webkitpy.common.system.executive import Executive, run_command, ScriptError

from webkitpy.common.system.deprecated_logging import error, log

def detect_scm_system(path):

    absolute_path = os.path.abspath(path)

    if SVN.in_working_directory(absolute_path):

        return SVN(cwd=absolute_path)

    if Git.in_working_directory(absolute_path):

        return Git(cwd=absolute_path)

    return None

def first_non_empty_line_after_index(lines, index=0):

    first_non_empty_line = index

    for line in lines[index:]:

        if re.match("^\s*$", line):

            first_non_empty_line += 1

        else:

            break

    return first_non_empty_line

class CommitMessage:

    def __init__(self, message):

        self.message_lines = message[first_non_empty_line_after_index(message, 0):]

    def body(self, lstrip=False):

        lines = self.message_lines[first_non_empty_line_after_index(self.message_lines, 1):]

        if lstrip:

            lines = [line.lstrip() for line in lines]

        return "\n".join(lines) + "\n"

    def description(self, lstrip=False, strip_url=False):

        line = self.message_lines[0]

        if lstrip:

            line = line.lstrip()

        if strip_url:

            line = re.sub("^(\s*)<.+> ", "\1", line)

        return line

    def message(self):

        return "\n".join(self.message_lines) + "\n"

class CheckoutNeedsUpdate(ScriptError):

    def __init__(self, script_args, exit_code, output, cwd):

        ScriptError.__init__(self, script_args=script_args, exit_code=exit_code, output=output, cwd=cwd)

def commit_error_handler(error):

    if re.search("resource out of date", error.output):

        raise CheckoutNeedsUpdate(script_args=error.script_args, exit_code=error.exit_code, output=error.output, cwd=error.cwd)

    Executive.default_error_handler(error)

class AuthenticationError(Exception):

    def __init__(self, server_host):

        self.server_host = server_host

class AmbiguousCommitError(Exception):

    def __init__(self, num_local_commits, working_directory_is_clean):

        self.num_local_commits = num_local_commits

        self.working_directory_is_clean = working_directory_is_clean

# SCM methods are expected to return paths relative to self.checkout_root.

class SCM:

    def __init__(self, cwd):

        self.cwd = cwd

        self.checkout_root = self.find_checkout_root(self.cwd)

        self.dryrun = False

    # A wrapper used by subclasses to create processes.

    def run(self, args, cwd=None, input=None, error_handler=None, return_exit_code=False, return_stderr=True, decode_output=True):

        # FIXME: We should set cwd appropriately.

        # FIXME: We should use Executive.

        return run_command(args,

                           cwd=cwd,

                           input=input,

                           error_handler=error_handler,

                           return_exit_code=return_exit_code,

                           return_stderr=return_stderr,

                           decode_output=decode_output)

    # SCM always returns repository relative path, but sometimes we need

    # absolute paths to pass to rm, etc.

    def absolute_path(self, repository_relative_path):

        return os.path.join(self.checkout_root, repository_relative_path)

    # FIXME: This belongs in Checkout, not SCM.

    def scripts_directory(self):

        return os.path.join(self.checkout_root, "WebKitTools", "Scripts")

    # FIXME: This belongs in Checkout, not SCM.

    def script_path(self, script_name):

        return os.path.join(self.scripts_directory(), script_name)

    def ensure_clean_working_directory(self, force_clean):

        if not force_clean and not self.working_directory_is_clean():

            # FIXME: Shouldn't this use cwd=self.checkout_root?

            print self.run(self.status_command(), error_handler=Executive.ignore_error)

            raise ScriptError(message="Working directory has modifications, pass --force-clean or --no-clean to continue.")

        log("Cleaning working directory")

        self.clean_working_directory()

    def ensure_no_local_commits(self, force):

        if not self.supports_local_commits():

            return

        commits = self.local_commits()

        if not len(commits):

            return

        if not force:

            error("Working directory has local commits, pass --force-clean to continue.")

        self.discard_local_commits()

    def run_status_and_extract_filenames(self, status_command, status_regexp):

        filenames = []

        # We run with cwd=self.checkout_root so that returned-paths are root-relative.

        for line in self.run(status_command, cwd=self.checkout_root).splitlines():

            match = re.search(status_regexp, line)

            if not match:

                continue

            # status = match.group('status')

            filename = match.group('filename')

            filenames.append(filename)

        return filenames

    def strip_r_from_svn_revision(self, svn_revision):

        match = re.match("^r(?P<svn_revision>\d+)", unicode(svn_revision))

        if (match):

            return match.group('svn_revision')

        return svn_revision

    def svn_revision_from_commit_text(self, commit_text):

        match = re.search(self.commit_success_regexp(), commit_text, re.MULTILINE)

        return match.group('svn_revision')

    @staticmethod

    def _subclass_must_implement():

        raise NotImplementedError("subclasses must implement")

    @staticmethod

    def in_working_directory(path):

        SCM._subclass_must_implement()

    @staticmethod

    def find_checkout_root(path):

        SCM._subclass_must_implement()

    @staticmethod

    def commit_success_regexp():

        SCM._subclass_must_implement()

    def working_directory_is_clean(self):

        self._subclass_must_implement()

    def clean_working_directory(self):

        self._subclass_must_implement()

    def status_command(self):

        self._subclass_must_implement()

    def add(self, path, return_exit_code=False):

        self._subclass_must_implement()

    def delete(self, path):

        self._subclass_must_implement()

    def changed_files(self, git_commit=None):

        self._subclass_must_implement()

    def changed_files_for_revision(self):

        self._subclass_must_implement()

    def added_files(self):

        self._subclass_must_implement()

    def conflicted_files(self):

        self._subclass_must_implement()

    def display_name(self):

        self._subclass_must_implement()

    def create_patch(self, git_commit=None):

        self._subclass_must_implement()

    def committer_email_for_revision(self, revision):

        self._subclass_must_implement()

    def contents_at_revision(self, path, revision):

        self._subclass_must_implement()

    def diff_for_revision(self, revision):

        self._subclass_must_implement()

    def diff_for_file(self, path, log=None):

        self._subclass_must_implement()

    def show_head(self, path):

        self._subclass_must_implement()

    def apply_reverse_diff(self, revision):

        self._subclass_must_implement()

    def revert_files(self, file_paths):

        self._subclass_must_implement()

    def commit_with_message(self, message, username=None, git_commit=None, force_squash=False):

        self._subclass_must_implement()

    def svn_commit_log(self, svn_revision):

        self._subclass_must_implement()

    def last_svn_commit_log(self):

        self._subclass_must_implement()

    # Subclasses must indicate if they support local commits,

    # but the SCM baseclass will only call local_commits methods when this is true.

    @staticmethod

    def supports_local_commits():

        SCM._subclass_must_implement()

    def remote_merge_base():

        SCM._subclass_must_implement()

    def commit_locally_with_message(self, message):

        error("Your source control manager does not support local commits.")

    def discard_local_commits(self):

        pass

    def local_commits(self):

        return []

class SVN(SCM):

    # FIXME: We should move these values to a WebKit-specific config. file.

    svn_server_host = "svn.webkit.org"

    svn_server_realm = "<http://svn.webkit.org:80> Mac OS Forge"

    def __init__(self, cwd):

        SCM.__init__(self, cwd)

        self.cached_version = None

        self._bogus_dir = None

    @staticmethod

    def in_working_directory(path):

        return os.path.isdir(os.path.join(path, '.svn'))

    @classmethod

    def find_uuid(cls, path):

        if not cls.in_working_directory(path):

            return None

        return cls.value_from_svn_info(path, 'Repository UUID')

    @classmethod

    def value_from_svn_info(cls, path, field_name):

        svn_info_args = ['svn', 'info', path]

        info_output = run_command(svn_info_args).rstrip()

        match = re.search("^%s: (?P<value>.+)$" % field_name, info_output, re.MULTILINE)

        if not match:

            raise ScriptError(script_args=svn_info_args, message='svn info did not contain a %s.' % field_name)

        return match.group('value')

    @staticmethod

    def find_checkout_root(path):

        uuid = SVN.find_uuid(path)

        # If |path| is not in a working directory, we're supposed to return |path|.

        if not uuid:

            return path

        # Search up the directory hierarchy until we find a different UUID.

        last_path = None

        while True:

            if uuid != SVN.find_uuid(path):

                return last_path

            last_path = path

            (path, last_component) = os.path.split(path)

            if last_path == path:

                return None

    @staticmethod

    def commit_success_regexp():

        return "^Committed revision (?P<svn_revision>\d+)\.$"

    def has_authorization_for_realm(self, realm=svn_server_realm, home_directory=os.getenv("HOME")):

        # Assumes find and grep are installed.

        if not os.path.isdir(os.path.join(home_directory, ".subversion")):

            return False

        find_args = ["find", ".subversion", "-type", "f", "-exec", "grep", "-q", realm, "{}", ";", "-print"];

        find_output = self.run(find_args, cwd=home_directory, error_handler=Executive.ignore_error).rstrip()

        return find_output and os.path.isfile(os.path.join(home_directory, find_output))

    def svn_version(self):

        if not self.cached_version:

            self.cached_version = self.run(['svn', '--version', '--quiet'])

        return self.cached_version

    def working_directory_is_clean(self):

        return self.run(["svn", "diff"], cwd=self.checkout_root, decode_output=False) == ""

    def clean_working_directory(self):

        # svn revert -R is not as awesome as git reset --hard.

        # It will leave added files around, causing later svn update

        # calls to fail on the bots.  We make this mirror git reset --hard

        # by deleting any added files as well.

        added_files = reversed(sorted(self.added_files()))

        # added_files() returns directories for SVN, we walk the files in reverse path

        # length order so that we remove files before we try to remove the directories.

        self.run(["svn", "revert", "-R", "."], cwd=self.checkout_root)

        for path in added_files:

            # This is robust against cwd != self.checkout_root

            absolute_path = self.absolute_path(path)

            # Completely lame that there is no easy way to remove both types with one call.

            if os.path.isdir(path):

                os.rmdir(absolute_path)

            else:

                os.remove(absolute_path)

    def status_command(self):

        return ['svn', 'status']

    def _status_regexp(self, expected_types):

        field_count = 6 if self.svn_version() > "1.6" else 5

        return "^(?P<status>[%s]).{%s} (?P<filename>.+)$" % (expected_types, field_count)

    def _add_parent_directories(self, path):

        """Does 'svn add' to the path and its parents."""

        if self.in_working_directory(path):

            return

        dirname = os.path.dirname(path)

        # We have dirname directry - ensure it added.

        if dirname != path:

            self._add_parent_directories(dirname)

        self.add(path)

    def add(self, path, return_exit_code=False):

        self._add_parent_directories(os.path.dirname(os.path.abspath(path)))

        return self.run(["svn", "add", path], return_exit_code=return_exit_code)

    def delete(self, path):

        parent, base = os.path.split(os.path.abspath(path))

        return self.run(["svn", "delete", "--force", base], cwd=parent)

    def changed_files(self, git_commit=None):

        return self.run_status_and_extract_filenames(self.status_command(), self._status_regexp("ACDMR"))

    def changed_files_for_revision(self, revision):

        # As far as I can tell svn diff --summarize output looks just like svn status output.

        # No file contents printed, thus utf-8 auto-decoding in self.run is fine.

        status_command = ["svn", "diff", "--summarize", "-c", revision]

        return self.run_status_and_extract_filenames(status_command, self._status_regexp("ACDMR"))

    def conflicted_files(self):

        return self.run_status_and_extract_filenames(self.status_command(), self._status_regexp("C"))

    def added_files(self):

        return self.run_status_and_extract_filenames(self.status_command(), self._status_regexp("A"))

    def deleted_files(self):

        return self.run_status_and_extract_filenames(self.status_command(), self._status_regexp("D"))

    @staticmethod

    def supports_local_commits():

        return False

    def display_name(self):

        return "svn"

    # FIXME: This method should be on Checkout.

    def create_patch(self, git_commit=None):

        """Returns a byte array (str()) representing the patch file.

        Patch files are effectively binary since they may contain

        files of multiple different encodings."""

        return self.run([self.script_path("svn-create-patch")],

            cwd=self.checkout_root, return_stderr=False,

            decode_output=False)

    def committer_email_for_revision(self, revision):

        return self.run(["svn", "propget", "svn:author", "--revprop", "-r", revision]).rstrip()

    def contents_at_revision(self, path, revision):

        """Returns a byte array (str()) containing the contents

        of path @ revision in the repository."""

        remote_path = "%s/%s" % (self._repository_url(), path)

        return self.run(["svn", "cat", "-r", revision, remote_path], decode_output=False)

    def diff_for_revision(self, revision):

        # FIXME: This should probably use cwd=self.checkout_root

        return self.run(['svn', 'diff', '-c', revision])

    def _bogus_dir_name(self):

        if sys.platform.startswith("win"):

            parent_dir = tempfile.gettempdir()

        else:

            parent_dir = sys.path[0]  # tempdir is not secure.

        return os.path.join(parent_dir, "temp_svn_config")

    def _setup_bogus_dir(self, log):

        self._bogus_dir = self._bogus_dir_name()

        if not os.path.exists(self._bogus_dir):

            os.mkdir(self._bogus_dir)

            self._delete_bogus_dir = True

        else:

            self._delete_bogus_dir = False

        if log:

            log.debug('  Html: temp config dir: "%s".', self._bogus_dir)

    def _teardown_bogus_dir(self, log):

        if self._delete_bogus_dir:

            shutil.rmtree(self._bogus_dir, True)

            if log:

                log.debug('  Html: removed temp config dir: "%s".', self._bogus_dir)

        self._bogus_dir = None

    def diff_for_file(self, path, log=None):

        self._setup_bogus_dir(log)

        try:

            args = ['svn', 'diff']

            if self._bogus_dir:

                args += ['--config-dir', self._bogus_dir]

            args.append(path)

            return self.run(args)

        finally:

            self._teardown_bogus_dir(log)

    def show_head(self, path):

        return self.run(['svn', 'cat', '-r', 'BASE', path], decode_output=False)

    def _repository_url(self):

        return self.value_from_svn_info(self.checkout_root, 'URL')

    def apply_reverse_diff(self, revision):

        # '-c -revision' applies the inverse diff of 'revision'

        svn_merge_args = ['svn', 'merge', '--non-interactive', '-c', '-%s' % revision, self._repository_url()]

        log("WARNING: svn merge has been known to take more than 10 minutes to complete.  It is recommended you use git for rollouts.")

        log("Running '%s'" % " ".join(svn_merge_args))

        # FIXME: Should this use cwd=self.checkout_root?

        self.run(svn_merge_args)

    def revert_files(self, file_paths):

        # FIXME: This should probably use cwd=self.checkout_root.

        self.run(['svn', 'revert'] + file_paths)

    def commit_with_message(self, message, username=None, git_commit=None, force_squash=False):

        # git-commit and force are not used by SVN.

        if self.dryrun:

            # Return a string which looks like a commit so that things which parse this output will succeed.

            return "Dry run, no commit.\nCommitted revision 0."

        svn_commit_args = ["svn", "commit"]

        if not username and not self.has_authorization_for_realm():

            raise AuthenticationError(self.svn_server_host)

        if username:

            svn_commit_args.extend(["--username", username])

        svn_commit_args.extend(["-m", message])

        # FIXME: Should this use cwd=self.checkout_root?

        return self.run(svn_commit_args, error_handler=commit_error_handler)

    def svn_commit_log(self, svn_revision):

        svn_revision = self.strip_r_from_svn_revision(svn_revision)

        return self.run(['svn', 'log', '--non-interactive', '--revision', svn_revision])

    def last_svn_commit_log(self):

        # BASE is the checkout revision, HEAD is the remote repository revision

        # http://svnbook.red-bean.com/en/1.0/ch03s03.html

        return self.svn_commit_log('BASE')

    def propset(self, pname, pvalue, path):

        dir, base = os.path.split(path)

        return self.run(['svn', 'pset', pname, pvalue, base], cwd=dir)

    def propget(self, pname, path):

        dir, base = os.path.split(path)

        return self.run(['svn', 'pget', pname, base], cwd=dir).encode('utf-8').rstrip("\n")

# All git-specific logic should go here.

class Git(SCM):

    def __init__(self, cwd):

        SCM.__init__(self, cwd)

    @classmethod

    def in_working_directory(cls, path):

        return run_command(['git', 'rev-parse', '--is-inside-work-tree'], cwd=path, error_handler=Executive.ignore_error).rstrip() == "true"