Remove Runner.cmd_runner and Store.cmd_runner

asottile · asottile · commit 6141c419ee9a · 2017-09-05T14:49:31.000-07:00
diff --git a/pre_commit/commands/run.py b/pre_commit/commands/run.py
@@ -192,17 +192,14 @@ def get_repo_hooks(runner):
             yield (repo, hook)
 
 
-def _has_unmerged_paths(runner):
-    _, stdout, _ = runner.cmd_runner.run(['git', 'ls-files', '--unmerged'])
+def _has_unmerged_paths():
+    _, stdout, _ = cmd_output('git', 'ls-files', '--unmerged')
     return bool(stdout.strip())
 
 
 def _has_unstaged_config(runner):
-    retcode, _, _ = runner.cmd_runner.run(
-        (
-            'git', 'diff', '--no-ext-diff', '--exit-code',
-            runner.config_file_path,
-        ),
+    retcode, _, _ = cmd_output(
+        'git', 'diff', '--no-ext-diff', '--exit-code', runner.config_file_path,
         retcode=None,
     )
     # be explicit, other git errors don't mean it has an unstaged config.
@@ -213,7 +210,7 @@ def run(runner, args, environ=os.environ):
     no_stash = args.all_files or bool(args.files)
 
     # Check if we have unresolved merge conflict files and fail fast.
-    if _has_unmerged_paths(runner):
+    if _has_unmerged_paths():
         logger.error('Unmerged files.  Resolve before committing.')
         return 1
     if bool(args.source) != bool(args.origin):
@@ -234,7 +231,7 @@ def run(runner, args, environ=os.environ):
     if no_stash:
         ctx = noop_context()
     else:
-        ctx = staged_files_only(runner.cmd_runner)
+        ctx = staged_files_only(runner.store.directory)
 
     with ctx:
         repo_hooks = list(get_repo_hooks(runner))
diff --git a/pre_commit/runner.py b/pre_commit/runner.py
@@ -57,11 +57,6 @@ def pre_commit_path(self):
     def pre_push_path(self):
         return self.get_hook_path('pre-push')
 
-    @cached_property
-    def cmd_runner(self):
-        # TODO: remove this and inline runner.store.cmd_runner
-        return self.store.cmd_runner
-
     @cached_property
     def store(self):
         return Store()
diff --git a/pre_commit/staged_files_only.py b/pre_commit/staged_files_only.py
@@ -3,44 +3,41 @@
 import contextlib
 import io
 import logging
+import os.path
 import time
 
 from pre_commit.util import CalledProcessError
+from pre_commit.util import cmd_output
 
 
 logger = logging.getLogger('pre_commit')
 
 
-def _git_apply(cmd_runner, patch):
+def _git_apply(patch):
     args = ('apply', '--whitespace=nowarn', patch)
     try:
-        cmd_runner.run(('git',) + args, encoding=None)
+        cmd_output('git', *args, encoding=None)
     except CalledProcessError:
         # Retry with autocrlf=false -- see #570
-        cmd = ('git', '-c', 'core.autocrlf=false') + args
-        cmd_runner.run(cmd, encoding=None)
+        cmd_output('git', '-c', 'core.autocrlf=false', *args, encoding=None)
 
 
 @contextlib.contextmanager
-def staged_files_only(cmd_runner):
+def staged_files_only(patch_dir):
     """Clear any unstaged changes from the git working directory inside this
     context.
-
-    Args:
-        cmd_runner - PrefixedCommandRunner
     """
     # Determine if there are unstaged files
-    tree = cmd_runner.run(('git', 'write-tree'))[1].strip()
-    retcode, diff_stdout_binary, _ = cmd_runner.run(
-        (
-            'git', 'diff-index', '--ignore-submodules', '--binary',
-            '--exit-code', '--no-color', '--no-ext-diff', tree, '--',
-        ),
+    tree = cmd_output('git', 'write-tree')[1].strip()
+    retcode, diff_stdout_binary, _ = cmd_output(
+        'git', 'diff-index', '--ignore-submodules', '--binary',
+        '--exit-code', '--no-color', '--no-ext-diff', tree, '--',
         retcode=None,
         encoding=None,
     )
     if retcode and diff_stdout_binary.strip():
-        patch_filename = cmd_runner.path('patch{}'.format(int(time.time())))
+        patch_filename = 'patch{}'.format(int(time.time()))
+        patch_filename = os.path.join(patch_dir, patch_filename)
         logger.warning('Unstaged files detected.')
         logger.info(
             'Stashing unstaged files to {}.'.format(patch_filename),
@@ -50,13 +47,13 @@ def staged_files_only(cmd_runner):
             patch_file.write(diff_stdout_binary)
 
         # Clear the working directory of unstaged changes
-        cmd_runner.run(('git', 'checkout', '--', '.'))
+        cmd_output('git', 'checkout', '--', '.')
         try:
             yield
         finally:
             # Try to apply the patch we saved
             try:
-                _git_apply(cmd_runner, patch_filename)
+                _git_apply(patch_filename)
             except CalledProcessError:
                 logger.warning(
                     'Stashed changes conflicted with hook auto-fixes... '
@@ -65,8 +62,8 @@ def staged_files_only(cmd_runner):
                 # We failed to apply the patch, presumably due to fixes made
                 # by hooks.
                 # Roll back the changes made by hooks.
-                cmd_runner.run(('git', 'checkout', '--', '.'))
-                _git_apply(cmd_runner, patch_filename)
+                cmd_output('git', 'checkout', '--', '.')
+                _git_apply(patch_filename)
             logger.info('Restored changes from {}.'.format(patch_filename))
     else:
         # There weren't any staged files so we don't need to do anything
diff --git a/pre_commit/store.py b/pre_commit/store.py
@@ -11,7 +11,6 @@
 
 import pre_commit.constants as C
 from pre_commit import file_lock
-from pre_commit.prefixed_command_runner import PrefixedCommandRunner
 from pre_commit.util import clean_path_on_failure
 from pre_commit.util import cmd_output
 from pre_commit.util import copy_tree_to_path
@@ -162,10 +161,6 @@ def make_local_strategy(directory):
             make_local_strategy,
         )
 
-    @cached_property
-    def cmd_runner(self):
-        return PrefixedCommandRunner(self.directory)
-
     @cached_property
     def db_path(self):
         return os.path.join(self.directory, 'db.db')
diff --git a/tests/commands/run_test.py b/tests/commands/run_test.py
@@ -7,7 +7,6 @@
 import sys
 from collections import OrderedDict
 
-import mock
 import pytest
 
 import pre_commit.constants as C
@@ -327,11 +326,10 @@ def test_origin_source_error_msg(
         assert warning_msg not in printed
 
 
-@pytest.mark.parametrize(('output', 'expected'), (('some', True), ('', False)))
-def test_has_unmerged_paths(output, expected):
-    mock_runner = mock.Mock()
-    mock_runner.cmd_runner.run.return_value = (1, output, '')
-    assert _has_unmerged_paths(mock_runner) is expected
+def test_has_unmerged_paths(in_merge_conflict):
+    assert _has_unmerged_paths() is True
+    cmd_output('git', 'add', '.')
+    assert _has_unmerged_paths() is False
 
 
 def test_merge_conflict(cap_out, in_merge_conflict, mock_out_store_directory):
diff --git a/tests/runner_test.py b/tests/runner_test.py
@@ -133,9 +133,3 @@ def test_pre_push_path(in_tmpdir):
     runner = Runner(path, C.CONFIG_FILE)
     expected_path = os.path.join(path, '.git', 'hooks', 'pre-push')
     assert runner.pre_push_path == expected_path
-
-
-def test_cmd_runner(mock_out_store_directory):
-    runner = Runner(os.path.join('foo', 'bar'), C.CONFIG_FILE)
-    ret = runner.cmd_runner
-    assert ret.prefix_dir == os.path.join(mock_out_store_directory) + os.sep
diff --git a/tests/staged_files_only_test.py b/tests/staged_files_only_test.py
diff --git a/tests/store_test.py b/tests/store_test.py
