Merge scm.py and git.py in webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/git.py

 # Copyright (c) 2009, 2010, 2011 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
@@ skipping 10 matching lines @@
 # 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.
 
 import datetime
+import logging
 import re
 
-from webkitpy.common.checkout.scm.scm import SCM
 from webkitpy.common.memoized import memoized
 from webkitpy.common.system.executive import Executive, ScriptError
+from webkitpy.common.system.filesystem import FileSystem
+
+_log = logging.getLogger(__name__)
 
 
-class AmbiguousCommitError(Exception):
-
-    def __init__(self, num_local_commits, has_working_directory_changes):
-        Exception.__init__(self, "Found %s local commits and the working directory is %s" % (
-            num_local_commits, ["clean", "not clean"][has_working_directory_changes]))
-        self.num_local_commits = num_local_commits
-        self.has_working_directory_changes = has_working_directory_changes
-
-
-class Git(SCM):
+class Git(object):
+    # Unless otherwise specified, methods are expected to return paths relative
+    # to self.checkout_root.
 
     # Git doesn't appear to document error codes, but seems to return
     # 1 or 128, mostly.
     ERROR_FILE_IS_MISSING = 128
 
     executable_name = 'git'
 
-    def __init__(self, cwd, **kwargs):
-        SCM.__init__(self, cwd, **kwargs)
+    def __init__(self, cwd, executive=None, filesystem=None):
+        self.cwd = cwd
+        self._executive = executive or Executive()
+        self._filesystem = filesystem or FileSystem()
+        self.checkout_root = self.find_checkout_root(self.cwd)
 
-    def _run_git(self, command_args, **kwargs):
+    def _run_git(self,
+                 command_args,
+                 cwd=None,
+                 input=None,  # pylint: disable=redefined-builtin
+                 timeout_seconds=None,
+                 decode_output=True,
+                 return_exit_code=False):
         full_command_args = [self.executable_name] + command_args
-        full_kwargs = kwargs
-        if 'cwd' not in full_kwargs:
-            full_kwargs['cwd'] = self.checkout_root
-        return self._run(full_command_args, **full_kwargs)
+        cwd = cwd or self.checkout_root
+        return self._executive.run_command(
+            full_command_args,
+            cwd=cwd,
+            input=input,
+            timeout_seconds=timeout_seconds,
+            return_exit_code=return_exit_code,
+            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 self._filesystem.join(self.checkout_root, repository_relative_path)
 
     @classmethod
     def in_working_directory(cls, path, executive=None):
         try:
             executive = executive or Executive()
             return executive.run_command([cls.executable_name, 'rev-parse', '--is-inside-work-tree'],
                                          cwd=path, error_handler=Executive.ignore_error).rstrip() == "true"
         except OSError:
             # The Windows bots seem to through a WindowsError when git isn't installed.
             return False
@@ skipping 49 matching lines @@
         # for machine parsing. Lines are terminated with NUL rather than LF.
         unstaged_changes = {}
         change_lines = self._run_git(['status', '-z']).rstrip('\x00').split('\x00')
         for line in change_lines:
             if line[1] == ' ':
                 continue  # Already staged for commit.
             path = line[3:]
             unstaged_changes[path] = line[1]
         return unstaged_changes
 
-    def status_command(self):
-        # git status returns non-zero when there are changes, so we use git diff name --name-status HEAD instead.
-        # No file contents printed, thus utf-8 autodecoding in self.run is fine.
-        return [self.executable_name, "diff", "--name-status", "--no-renames", "HEAD"]
-
-    def _status_regexp(self, expected_types):
-        return '^(?P<status>[%s])\t(?P<filename>.+)$' % expected_types
-
     def add_all(self, pathspec=None):
         command = ['add', '--all']
         if pathspec:
             command.append(pathspec)
         return self._run_git(command)
 
-    def add_list(self, paths, return_exit_code=False, recurse=True):
+    def add_list(self, paths, return_exit_code=False):
         return self._run_git(["add"] + paths, return_exit_code=return_exit_code)
 
     def delete_list(self, paths):
         return self._run_git(["rm", "-f"] + paths)
 
     def move(self, origin, destination):
         return self._run_git(["mv", "-f", origin, destination])
 
     def exists(self, path):
         return_code = self._run_git(["show", "HEAD:%s" % path], return_exit_code=True, decode_output=False)
@@ skipping 43 matching lines @@
         return self._remote_merge_base()
 
     def changed_files(self, git_commit=None):
         # FIXME: --diff-filter could be used to avoid the "extract_filenames" step.
         status_command = [self.executable_name, 'diff', '-r', '--name-status',
                           "--no-renames", "--no-ext-diff", "--full-index", self._merge_base(git_commit)]
         # FIXME: I'm not sure we're returning the same set of files that SVN.changed_files is.
         # Added (A), Copied (C), Deleted (D), Modified (M), Renamed (R)
         return self._run_status_and_extract_filenames(status_command, self._status_regexp("ADM"))
 
-    def _added_files(self):
+    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"))
+    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_git(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 status_command(self):
+        # git status returns non-zero when there are changes, so we use git diff name --name-status HEAD instead.
+        # No file contents printed, thus utf-8 autodecoding in self.run is fine.
+        return ["diff", "--name-status", "--no-renames", "HEAD"]
+
+    def _status_regexp(self, expected_types):
+        return '^(?P<status>[%s])\t(?P<filename>.+)$' % expected_types
 
     @staticmethod
     def supports_local_commits():
         return True
 
     def display_name(self):
         return "git"
 
     def most_recent_log_matching(self, grep_str, path):
         # We use '--grep=' + foo rather than '--grep', foo because
         # git 1.7.0.4 (and earlier) didn't support the separate arg.
         return self._run_git(['log', '-1', '--grep=' + grep_str, '--date=iso', self.find_checkout_root(path)])
 
     def _commit_position_from_git_log(self, git_log):
         match = re.search(r"^\s*Cr-Commit-Position:.*@\{#(?P<commit_position>\d+)\}", git_log, re.MULTILINE)
         if not match:
             return ""
         return int(match.group('commit_position'))
 
     def commit_position(self, path):
+        """Returns the latest chromium commit position found in the checkout."""
         git_log = self.most_recent_log_matching('Cr-Commit-Position:', path)
         return self._commit_position_from_git_log(git_log)
 
     def _commit_position_regex_for_timestamp(self):
         return 'Cr-Commit-Position:.*@{#%s}'
 
     def timestamp_of_revision(self, path, revision):
         git_log = self.most_recent_log_matching(self._commit_position_regex_for_timestamp() % revision, path)
         match = re.search(r"^Date:\s*(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}) ([+-])(\d{2})(\d{2})$", git_log, re.MULTILINE)
         if not match:
             return ""
 
         # Manually modify the timezone since Git doesn't have an option to show it in UTC.
         # Git also truncates milliseconds but we're going to ignore that for now.
         time_with_timezone = datetime.datetime(int(match.group(1)), int(match.group(2)), int(match.group(3)),
                                                int(match.group(4)), int(match.group(5)), int(match.group(6)), 0)
 
         sign = 1 if match.group(7) == '+' else -1
         time_without_timezone = time_with_timezone - \
             datetime.timedelta(hours=sign * int(match.group(8)), minutes=int(match.group(9)))
         return time_without_timezone.strftime('%Y-%m-%dT%H:%M:%SZ')
 
     def create_patch(self, git_commit=None, changed_files=None):
         """Returns a byte array (str()) representing the patch file.
         Patch files are effectively binary since they may contain
         files of multiple different encodings.
         """
+        order = self._patch_order()
+        command = [
+            'diff',
+            '--binary',
+            '--no-color',
+            "--no-ext-diff",
+            "--full-index",
+            "--no-renames",
+            "--src-prefix=a/",
+            "--dst-prefix=b/",
 
+        ]
+        if order:
+            command.append(order)
+        command += [self._merge_base(git_commit), "--"]
+        if changed_files:
+            command += changed_files
+        return self._run_git(command, decode_output=False, cwd=self.checkout_root)
+
+    def _patch_order(self):
         # Put code changes at the top of the patch and layout tests
         # at the bottom, this makes for easier reviewing.
         config_path = self._filesystem.dirname(self._filesystem.path_to_module('webkitpy.common.config'))
         order_file = self._filesystem.join(config_path, 'orderfile')
-        order = ""
         if self._filesystem.exists(order_file):
-            order = "-O%s" % order_file
-
-        command = [self.executable_name, 'diff', '--binary', '--no-color', "--no-ext-diff",
-                   "--full-index", "--no-renames", "--src-prefix=a/", "--dst-prefix=b/",
-                   order, self._merge_base(git_commit), "--"]
-        if changed_files:
-            command += changed_files
-        return self._run(command, decode_output=False, cwd=self.checkout_root)
+            return "-O%s" % order_file
+        return ""
 
     @memoized
     def commit_position_from_git_commit(self, git_commit):
         git_log = self.git_commit_detail(git_commit)
         return self._commit_position_from_git_log(git_log)
 
     def checkout_branch(self, name):
         self._run_git(['checkout', '-q', name])
 
     def create_clean_branch(self, name):
@@ skipping 17 matching lines @@
         # Use references so that we can avoid collisions, e.g. we don't want to operate on refs/heads/trunk if it exists.
         remote_master_ref = 'refs/remotes/origin/master'
         if not self._branch_ref_exists(remote_master_ref):
             raise ScriptError(message="Can't find a branch to diff against. %s does not exist" % remote_master_ref)
         return remote_master_ref
 
     def commit_locally_with_message(self, message):
         command = ['commit', '--all', '-F', '-']
         self._run_git(command, input=message)
 
-    # These methods are git specific and are meant to provide support for the Git oriented workflow
-    # that Blink is moving towards, hence there are no equivalent methods in the SVN class.
-
     def pull(self, timeout_seconds=None):
         self._run_git(['pull'], timeout_seconds=timeout_seconds)
 
     def latest_git_commit(self):
         return self._run_git(['log', '-1', '--format=%H']).strip()
 
     def git_commits_since(self, commit):
         return self._run_git(['log', commit + '..master', '--format=%H', '--reverse']).split()
 
-    def git_commit_detail(self, commit, format=None):
+    def git_commit_detail(self, commit, format=None):  # pylint: disable=redefined-builtin
         args = ['log', '-1', commit]
         if format:
             args.append('--format=' + format)
         return self._run_git(args)
 
     def affected_files(self, commit):
         output = self._run_git(['log', '-1', '--format=', '--name-only', commit])
         return output.strip().split('\n')
 
     def _branch_tracking_remote_master(self):
@@ skipping 10 matching lines @@
         if self.current_branch() != self._branch_tracking_remote_master():
             return False
         if len(self._local_commits(self._branch_tracking_remote_master())) > 0:
             return False
         return True
 
     def ensure_cleanly_tracking_remote_master(self):
         self._discard_working_directory_changes()
         self._run_git(['checkout', '-q', self._branch_tracking_remote_master()])
         self._discard_local_commits()