pre-commit · asottile · Jan 12, 2018 · Jan 12, 2018
diff --git a/pre_commit/languages/all.py b/pre_commit/languages/all.py
@@ -23,25 +23,25 @@
 #     return 'default' if there is no better option.
 #    """
 #
-# def healthy(repo_cmd_runner, language_version):
+# def healthy(prefix, language_version):
 #     """Return whether or not the environment is considered functional."""
 #
-# def install_environment(repo_cmd_runner, version, additional_dependencies):
+# def install_environment(prefix, version, additional_dependencies):
 #     """Installs a repository in the given repository.  Note that the current
 #     working directory will already be inside the repository.
 #
 #     Args:
-#         repo_cmd_runner - `PrefixedCommandRunner` bound to the repository.
+#         prefix - `Prefix` bound to the repository.
 #         version - A version specified in the hook configuration or
 #             'default'.
 #     """
 #
-# def run_hook(repo_cmd_runner, hook, file_args):
+# def run_hook(prefix, hook, file_args):
 #     """Runs a hook and returns the returncode and output of running that
 #     hook.
 #
 #     Args:
-#         repo_cmd_runner - `PrefixedCommandRunner` bound to the repository.
+#         prefix - `Prefix` bound to the repository.
 #         hook - Hook dictionary
 #         file_args - The files to be run
 #
@@ -62,6 +62,4 @@
     'swift': swift,
     'system': system,
 }
-
-
-all_languages = languages.keys()
+all_languages = sorted(languages)
diff --git a/pre_commit/languages/docker.py b/pre_commit/languages/docker.py
@@ -22,10 +22,9 @@ def md5(s):  # pragma: windows no cover
     return hashlib.md5(five.to_bytes(s)).hexdigest()
 
 
-def docker_tag(repo_cmd_runner):  # pragma: windows no cover
-    return 'pre-commit-{}'.format(
-        md5(os.path.basename(repo_cmd_runner.path())),
-    ).lower()
+def docker_tag(prefix):  # pragma: windows no cover
+    md5sum = md5(os.path.basename(prefix.prefix_dir)).lower()
+    return 'pre-commit-{}'.format(md5sum)
 
 
 def docker_is_running():  # pragma: windows no cover
@@ -41,39 +40,36 @@ def assert_docker_available():  # pragma: windows no cover
     )
 
 
-def build_docker_image(repo_cmd_runner, **kwargs):  # pragma: windows no cover
+def build_docker_image(prefix, **kwargs):  # pragma: windows no cover
     pull = kwargs.pop('pull')
     assert not kwargs, kwargs
     cmd = (
         'docker', 'build',
-        '--tag', docker_tag(repo_cmd_runner),
+        '--tag', docker_tag(prefix),
         '--label', PRE_COMMIT_LABEL,
     )
     if pull:
         cmd += ('--pull',)
     # This must come last for old versions of docker.  See #477
     cmd += ('.',)
-    helpers.run_setup_cmd(repo_cmd_runner, cmd)
+    helpers.run_setup_cmd(prefix, cmd)
 
 
 def install_environment(
-        repo_cmd_runner, version, additional_dependencies,
+        prefix, version, additional_dependencies,
 ):  # pragma: windows no cover
-    assert repo_cmd_runner.exists('Dockerfile'), (
-        'No Dockerfile was found in the hook repository'
-    )
     helpers.assert_version_default('docker', version)
     helpers.assert_no_additional_deps('docker', additional_dependencies)
     assert_docker_available()
 
-    directory = repo_cmd_runner.path(
+    directory = prefix.path(
         helpers.environment_dir(ENVIRONMENT_DIR, 'default'),
     )
 
     # Docker doesn't really have relevant disk environment, but pre-commit
     # still needs to cleanup it's state files on failure
     with clean_path_on_failure(directory):
-        build_docker_image(repo_cmd_runner, pull=True)
+        build_docker_image(prefix, pull=True)
         os.mkdir(directory)
 
 
@@ -90,15 +86,15 @@ def docker_cmd():
     )
 
 
-def run_hook(repo_cmd_runner, hook, file_args):  # pragma: windows no cover
+def run_hook(prefix, hook, file_args):  # pragma: windows no cover
     assert_docker_available()
     # Rebuild the docker image in case it has gone missing, as many people do
     # automated cleanup of docker images.
-    build_docker_image(repo_cmd_runner, pull=False)
+    build_docker_image(prefix, pull=False)
 
     hook_cmd = helpers.to_cmd(hook)
     entry_exe, cmd_rest = hook_cmd[0], hook_cmd[1:]
 
-    entry_tag = ('--entrypoint', entry_exe, docker_tag(repo_cmd_runner))
+    entry_tag = ('--entrypoint', entry_exe, docker_tag(prefix))
     cmd = docker_cmd() + entry_tag + cmd_rest
     return xargs(cmd, file_args)
diff --git a/pre_commit/languages/docker_image.py b/pre_commit/languages/docker_image.py
@@ -13,7 +13,7 @@
 install_environment = helpers.no_install
 
 
-def run_hook(repo_cmd_runner, hook, file_args):  # pragma: windows no cover
+def run_hook(prefix, hook, file_args):  # pragma: windows no cover
     assert_docker_available()
     cmd = docker_cmd() + helpers.to_cmd(hook)
     return xargs(cmd, file_args)
diff --git a/pre_commit/languages/golang.py b/pre_commit/languages/golang.py
@@ -26,8 +26,8 @@ def get_env_patch(venv):
 
 
 @contextlib.contextmanager
-def in_env(repo_cmd_runner):
-    envdir = repo_cmd_runner.path(
+def in_env(prefix):
+    envdir = prefix.path(
         helpers.environment_dir(ENVIRONMENT_DIR, 'default'),
     )
     with envcontext(get_env_patch(envdir)):
@@ -50,20 +50,18 @@ def guess_go_dir(remote_url):
         return 'unknown_src_dir'
 
 
-def install_environment(repo_cmd_runner, version, additional_dependencies):
+def install_environment(prefix, version, additional_dependencies):
     helpers.assert_version_default('golang', version)
-    directory = repo_cmd_runner.path(
+    directory = prefix.path(
         helpers.environment_dir(ENVIRONMENT_DIR, 'default'),
     )
 
     with clean_path_on_failure(directory):
-        remote = git.get_remote_url(repo_cmd_runner.path())
+        remote = git.get_remote_url(prefix.prefix_dir)
         repo_src_dir = os.path.join(directory, 'src', guess_go_dir(remote))
 
         # Clone into the goenv we'll create
-        helpers.run_setup_cmd(
-            repo_cmd_runner, ('git', 'clone', '.', repo_src_dir),
-        )
+        helpers.run_setup_cmd(prefix, ('git', 'clone', '.', repo_src_dir))
 
         if sys.platform == 'cygwin':  # pragma: no cover
             _, gopath, _ = cmd_output('cygpath', '-w', directory)
@@ -75,10 +73,10 @@ def install_environment(repo_cmd_runner, version, additional_dependencies):
         for dependency in additional_dependencies:
             cmd_output('go', 'get', dependency, cwd=repo_src_dir, env=env)
         # Same some disk space, we don't need these after installation
-        rmtree(repo_cmd_runner.path(directory, 'src'))
-        rmtree(repo_cmd_runner.path(directory, 'pkg'))
+        rmtree(prefix.path(directory, 'src'))
+        rmtree(prefix.path(directory, 'pkg'))
 
 
-def run_hook(repo_cmd_runner, hook, file_args):
-    with in_env(repo_cmd_runner):
+def run_hook(prefix, hook, file_args):
+    with in_env(prefix):
         return xargs(helpers.to_cmd(hook), file_args)
diff --git a/pre_commit/languages/helpers.py b/pre_commit/languages/helpers.py
@@ -5,8 +5,8 @@
 from pre_commit.util import cmd_output
 
 
-def run_setup_cmd(runner, cmd):
-    cmd_output(*cmd, cwd=runner.prefix_dir, encoding=None)
+def run_setup_cmd(prefix, cmd):
+    cmd_output(*cmd, cwd=prefix.prefix_dir, encoding=None)
 
 
 def environment_dir(ENVIRONMENT_DIR, language_version):
@@ -39,9 +39,9 @@ def basic_get_default_version():
     return 'default'
 
 
-def basic_healthy(repo_cmd_runner, language_version):
+def basic_healthy(prefix, language_version):
     return True
 
 
-def no_install(repo_cmd_runner, version, additional_dependencies):
+def no_install(prefix, version, additional_dependencies):
     raise AssertionError('This type is not installable')
diff --git a/pre_commit/languages/node.py b/pre_commit/languages/node.py
@@ -33,40 +33,35 @@ def get_env_patch(venv):  # pragma: windows no cover
 
 
 @contextlib.contextmanager
-def in_env(repo_cmd_runner, language_version):  # pragma: windows no cover
-    envdir = repo_cmd_runner.path(
+def in_env(prefix, language_version):  # pragma: windows no cover
+    envdir = prefix.path(
         helpers.environment_dir(ENVIRONMENT_DIR, language_version),
     )
     with envcontext(get_env_patch(envdir)):
         yield
 
 
 def install_environment(
-        repo_cmd_runner, version, additional_dependencies,
+        prefix, version, additional_dependencies,
 ):  # pragma: windows no cover
     additional_dependencies = tuple(additional_dependencies)
-    assert repo_cmd_runner.exists('package.json')
+    assert prefix.exists('package.json')
     directory = helpers.environment_dir(ENVIRONMENT_DIR, version)
 
-    env_dir = repo_cmd_runner.path(directory)
+    env_dir = prefix.path(directory)
     with clean_path_on_failure(env_dir):
-        cmd = [
-            sys.executable, '-m', 'nodeenv', '--prebuilt',
-            '{{prefix}}{}'.format(directory),
-        ]
-
+        cmd = [sys.executable, '-m', 'nodeenv', '--prebuilt', env_dir]
         if version != 'default':
             cmd.extend(['-n', version])
+        cmd_output(*cmd)
 
-        repo_cmd_runner.run(cmd)
-
-        with in_env(repo_cmd_runner, version):
+        with in_env(prefix, version):
             helpers.run_setup_cmd(
-                repo_cmd_runner,
+                prefix,
                 ('npm', 'install', '-g', '.') + additional_dependencies,
             )
 
 
-def run_hook(repo_cmd_runner, hook, file_args):  # pragma: windows no cover
-    with in_env(repo_cmd_runner, hook['language_version']):
+def run_hook(prefix, hook, file_args):  # pragma: windows no cover
+    with in_env(prefix, hook['language_version']):
         return xargs(helpers.to_cmd(hook), file_args)
diff --git a/pre_commit/languages/pcre.py b/pre_commit/languages/pcre.py
@@ -13,7 +13,7 @@
 install_environment = helpers.no_install
 
 
-def run_hook(repo_cmd_runner, hook, file_args):
+def run_hook(prefix, hook, file_args):
     # For PCRE the entry is the regular expression to match
     cmd = (GREP, '-H', '-n', '-P') + tuple(hook['args']) + (hook['entry'],)
 

diff --git a/pre_commit/languages/pygrep.py b/pre_commit/languages/pygrep.py
@@ -27,7 +27,7 @@ def _process_filename_by_line(pattern, filename):
     return retv
 
 
-def run_hook(repo_cmd_runner, hook, file_args):
+def run_hook(prefix, hook, file_args):
     exe = (sys.executable, '-m', __name__)
     exe += tuple(hook['args']) + (hook['entry'],)
     return xargs(exe, file_args)

diff --git a/pre_commit/languages/python.py b/pre_commit/languages/python.py
@@ -33,8 +33,8 @@ def get_env_patch(venv):
 
 
 @contextlib.contextmanager
-def in_env(repo_cmd_runner, language_version):
-    envdir = repo_cmd_runner.path(
+def in_env(prefix, language_version):
+    envdir = prefix.path(
         helpers.environment_dir(ENVIRONMENT_DIR, language_version),
     )
     with envcontext(get_env_patch(envdir)):
@@ -98,8 +98,8 @@ def get_default_version():
         return get_default_version()
 
 
-def healthy(repo_cmd_runner, language_version):
-    with in_env(repo_cmd_runner, language_version):
+def healthy(prefix, language_version):
+    with in_env(prefix, language_version):
         retcode, _, _ = cmd_output(
             'python', '-c', 'import ctypes, datetime, io, os, ssl, weakref',
             retcode=None,
@@ -127,29 +127,26 @@ def norm_version(version):
     return os.path.expanduser(version)
 
 
-def install_environment(repo_cmd_runner, version, additional_dependencies):
+def install_environment(prefix, version, additional_dependencies):
     additional_dependencies = tuple(additional_dependencies)
     directory = helpers.environment_dir(ENVIRONMENT_DIR, version)
 
     # Install a virtualenv
-    with clean_path_on_failure(repo_cmd_runner.path(directory)):
-        venv_cmd = [
-            sys.executable, '-m', 'virtualenv',
-            '{{prefix}}{}'.format(directory),
-        ]
+    env_dir = prefix.path(directory)
+    with clean_path_on_failure(env_dir):
+        venv_cmd = [sys.executable, '-m', 'virtualenv', env_dir]
         if version != 'default':
             venv_cmd.extend(['-p', norm_version(version)])
         else:
             venv_cmd.extend(['-p', os.path.realpath(sys.executable)])
         venv_env = dict(os.environ, VIRTUALENV_NO_DOWNLOAD='1')
-        repo_cmd_runner.run(venv_cmd, cwd='/', env=venv_env)
-        with in_env(repo_cmd_runner, version):
+        cmd_output(*venv_cmd, cwd='/', env=venv_env)
+        with in_env(prefix, version):
             helpers.run_setup_cmd(
-                repo_cmd_runner,
-                ('pip', 'install', '.') + additional_dependencies,
+                prefix, ('pip', 'install', '.') + additional_dependencies,
             )
 
 
-def run_hook(repo_cmd_runner, hook, file_args):
-    with in_env(repo_cmd_runner, hook['language_version']):
+def run_hook(prefix, hook, file_args):
+    with in_env(prefix, hook['language_version']):
         return xargs(helpers.to_cmd(hook), file_args)