mirror/pre-commit
1
0
Fork 0
mirror of https://github.com/pre-commit/pre-commit.git synced 2026-01-25 02:08:41 -06:00
Code Issues Packages Projects Releases Wiki Activity

Move PrefixedCommandRunner -> Prefix

Browse Source
This commit is contained in:
Anthony Sottile
2018-01-11 21:41:48 -08:00
parent c751f629a6
commit 7d87da8acd
23 changed files with 270 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
pre_commit/languages/all.py
View File

@@ -23,25 +23,25 @@ from pre_commit.languages import system
# 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 @@ languages = {
'swift': swift,
'system': system,
}
all_languages = languages.keys()
all_languages = sorted(languages)

28
pre_commit/languages/docker.py
View File

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

2
pre_commit/languages/docker_image.py
View File

@@ -13,7 +13,7 @@ healthy = helpers.basic_healthy
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)

22
pre_commit/languages/golang.py
View File

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

8
pre_commit/languages/helpers.py
View File

@@ -5,8 +5,8 @@ import shlex
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')

27
pre_commit/languages/node.py
View File

@@ -33,8 +33,8 @@ 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)):
@@ -42,31 +42,26 @@ def in_env(repo_cmd_runner, language_version): # pragma: windows no cover
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)

2
pre_commit/languages/pcre.py
View File

@@ -13,7 +13,7 @@ healthy = helpers.basic_healthy
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'],)

2
pre_commit/languages/pygrep.py
View File

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

29
pre_commit/languages/python.py
View File

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

51
pre_commit/languages/ruby.py
View File

@@ -39,36 +39,32 @@ def get_env_patch(venv, language_version): # 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, language_version)):
yield
def _install_rbenv(
repo_cmd_runner, version='default',
): # pragma: windows no cover
def _install_rbenv(prefix, version='default'): # pragma: windows no cover
directory = helpers.environment_dir(ENVIRONMENT_DIR, version)
with tarfile.open(resource_filename('rbenv.tar.gz')) as tf:
tf.extractall(repo_cmd_runner.path('.'))
shutil.move(
repo_cmd_runner.path('rbenv'), repo_cmd_runner.path(directory),
)
tf.extractall(prefix.path('.'))
shutil.move(prefix.path('rbenv'), prefix.path(directory))
# Only install ruby-build if the version is specified
if version != 'default':
# ruby-download
with tarfile.open(resource_filename('ruby-download.tar.gz')) as tf:
tf.extractall(repo_cmd_runner.path(directory, 'plugins'))
tf.extractall(prefix.path(directory, 'plugins'))
# ruby-build
with tarfile.open(resource_filename('ruby-build.tar.gz')) as tf:
tf.extractall(repo_cmd_runner.path(directory, 'plugins'))
tf.extractall(prefix.path(directory, 'plugins'))
activate_path = repo_cmd_runner.path(directory, 'bin', 'activate')
activate_path = prefix.path(directory, 'bin', 'activate')
with io.open(activate_path, 'w') as activate_file:
# This is similar to how you would install rbenv to your home directory
# However we do a couple things to make the executables exposed and
@@ -84,7 +80,7 @@ def _install_rbenv(
# directory
"export GEM_HOME='{directory}/gems'\n"
'export PATH="$GEM_HOME/bin:$PATH"\n'
'\n'.format(directory=repo_cmd_runner.path(directory)),
'\n'.format(directory=prefix.path(directory)),
)
# If we aren't using the system ruby, add a version here
@@ -101,35 +97,32 @@ def _install_ruby(runner, version): # pragma: windows no cover
def install_environment(
repo_cmd_runner, version, additional_dependencies,
prefix, version, additional_dependencies,
): # pragma: windows no cover
additional_dependencies = tuple(additional_dependencies)
directory = helpers.environment_dir(ENVIRONMENT_DIR, version)
with clean_path_on_failure(repo_cmd_runner.path(directory)):
with clean_path_on_failure(prefix.path(directory)):
# TODO: this currently will fail if there's no version specified and
# there's no system ruby installed. Is this ok?
_install_rbenv(repo_cmd_runner, version=version)
with in_env(repo_cmd_runner, version):
_install_rbenv(prefix, version=version)
with in_env(prefix, version):
# Need to call this before installing so rbenv's directories are
# set up
helpers.run_setup_cmd(repo_cmd_runner, ('rbenv', 'init', '-'))
helpers.run_setup_cmd(prefix, ('rbenv', 'init', '-'))
if version != 'default':
_install_ruby(repo_cmd_runner, version)
_install_ruby(prefix, version)
# Need to call this after installing to set up the shims
helpers.run_setup_cmd(repo_cmd_runner, ('rbenv', 'rehash'))
helpers.run_setup_cmd(prefix, ('rbenv', 'rehash'))
helpers.run_setup_cmd(
repo_cmd_runner,
('gem', 'build') + repo_cmd_runner.star('.gemspec'),
prefix, ('gem', 'build') + prefix.star('.gemspec'),
)
helpers.run_setup_cmd(
repo_cmd_runner,
(
('gem', 'install', '--no-ri', '--no-rdoc') +
repo_cmd_runner.star('.gem') + additional_dependencies
),
prefix,
('gem', 'install', '--no-ri', '--no-rdoc') +
prefix.star('.gem') + 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)

4
pre_commit/languages/script.py
View File

@@ -10,7 +10,7 @@ healthy = helpers.basic_healthy
install_environment = helpers.no_install
def run_hook(repo_cmd_runner, hook, file_args):
def run_hook(prefix, hook, file_args):
cmd = helpers.to_cmd(hook)
cmd = (repo_cmd_runner.prefix_dir + cmd[0],) + cmd[1:]
cmd = (prefix.prefix_dir + cmd[0],) + cmd[1:]
return xargs(cmd, file_args)

19
pre_commit/languages/swift.py
View File

@@ -7,6 +7,7 @@ from pre_commit.envcontext import envcontext
from pre_commit.envcontext import Var
from pre_commit.languages import helpers
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output
from pre_commit.xargs import xargs
ENVIRONMENT_DIR = 'swift_env'
@@ -22,8 +23,8 @@ def get_env_patch(venv): # pragma: windows no cover
@contextlib.contextmanager
def in_env(repo_cmd_runner): # pragma: windows no cover
envdir = repo_cmd_runner.path(
def in_env(prefix): # pragma: windows no cover
envdir = prefix.path(
helpers.environment_dir(ENVIRONMENT_DIR, 'default'),
)
with envcontext(get_env_patch(envdir)):
@@ -31,25 +32,25 @@ def in_env(repo_cmd_runner): # pragma: windows no cover
def install_environment(
repo_cmd_runner, version, additional_dependencies,
prefix, version, additional_dependencies,
): # pragma: windows no cover
helpers.assert_version_default('swift', version)
helpers.assert_no_additional_deps('swift', additional_dependencies)
directory = repo_cmd_runner.path(
directory = prefix.path(
helpers.environment_dir(ENVIRONMENT_DIR, 'default'),
)
# Build the swift package
with clean_path_on_failure(directory):
os.mkdir(directory)
repo_cmd_runner.run((
cmd_output(
'swift', 'build',
'-C', '{prefix}',
'-C', prefix.prefix_dir,
'-c', BUILD_CONFIG,
'--build-path', os.path.join(directory, BUILD_DIR),
))
)
def run_hook(repo_cmd_runner, hook, file_args): # pragma: windows no cover
with in_env(repo_cmd_runner):
def run_hook(prefix, hook, file_args): # pragma: windows no cover
with in_env(prefix):
return xargs(helpers.to_cmd(hook), file_args)

2
pre_commit/languages/system.py
View File

@@ -10,5 +10,5 @@ healthy = helpers.basic_healthy
install_environment = helpers.no_install
def run_hook(repo_cmd_runner, hook, file_args):
def run_hook(prefix, hook, file_args):
return xargs(helpers.to_cmd(hook), file_args)

20
pre_commit/prefix.py Normal file
View File

@@ -0,0 +1,20 @@
from __future__ import unicode_literals
import os.path
class Prefix(object):
def __init__(self, prefix_dir):
self.prefix_dir = prefix_dir.rstrip(os.sep) + os.sep
def path(self, *parts):
path = os.path.join(self.prefix_dir, *parts)
return os.path.normpath(path)
def exists(self, *parts):
return os.path.exists(self.path(*parts))
def star(self, end):
return tuple(
path for path in os.listdir(self.prefix_dir) if path.endswith(end)
)

50
pre_commit/prefixed_command_runner.py
View File

@@ -1,50 +0,0 @@
from __future__ import unicode_literals
import os.path
import subprocess
from pre_commit.util import cmd_output
class PrefixedCommandRunner(object):
"""A PrefixedCommandRunner allows you to run subprocess commands with
comand substitution.
For instance:
PrefixedCommandRunner('/tmp/foo').run(['{prefix}foo.sh', 'bar', 'baz'])
will run ['/tmp/foo/foo.sh', 'bar', 'baz']
"""
def __init__(
self,
prefix_dir,
popen=subprocess.Popen,
makedirs=os.makedirs,
):
self.prefix_dir = prefix_dir.rstrip(os.sep) + os.sep
self.__popen = popen
self.__makedirs = makedirs
def _create_path_if_not_exists(self):
if not os.path.exists(self.prefix_dir):
self.__makedirs(self.prefix_dir)
def run(self, cmd, **kwargs):
self._create_path_if_not_exists()
replaced_cmd = [
part.replace('{prefix}', self.prefix_dir) for part in cmd
]
return cmd_output(*replaced_cmd, __popen=self.__popen, **kwargs)
def path(self, *parts):
path = os.path.join(self.prefix_dir, *parts)
return os.path.normpath(path)
def exists(self, *parts):
return os.path.exists(self.path(*parts))
def star(self, end):
return tuple(
path for path in os.listdir(self.prefix_dir) if path.endswith(end)
)

62
pre_commit/repository.py
View File

@@ -21,7 +21,7 @@ from pre_commit.clientlib import load_manifest
from pre_commit.clientlib import MANIFEST_HOOK_DICT
from pre_commit.languages.all import languages
from pre_commit.languages.helpers import environment_dir
from pre_commit.prefixed_command_runner import PrefixedCommandRunner
from pre_commit.prefix import Prefix
from pre_commit.schema import apply_defaults
from pre_commit.schema import validate
@@ -33,22 +33,22 @@ def _state(additional_deps):
return {'additional_dependencies': sorted(additional_deps)}
def _state_filename(cmd_runner, venv):
return cmd_runner.path(
def _state_filename(prefix, venv):
return prefix.path(
venv, '.install_state_v' + C.INSTALLED_STATE_VERSION,
)
def _read_state(cmd_runner, venv):
filename = _state_filename(cmd_runner, venv)
def _read_state(prefix, venv):
filename = _state_filename(prefix, venv)
if not os.path.exists(filename):
return None
else:
return json.loads(io.open(filename).read())
def _write_state(cmd_runner, venv, state):
state_filename = _state_filename(cmd_runner, venv)
def _write_state(prefix, venv, state):
state_filename = _state_filename(prefix, venv)
staging = state_filename + 'staging'
with io.open(staging, 'w') as state_file:
state_file.write(five.to_text(json.dumps(state)))
@@ -56,24 +56,24 @@ def _write_state(cmd_runner, venv, state):
os.rename(staging, state_filename)
def _installed(cmd_runner, language_name, language_version, additional_deps):
def _installed(prefix, language_name, language_version, additional_deps):
language = languages[language_name]
venv = environment_dir(language.ENVIRONMENT_DIR, language_version)
return (
venv is None or (
_read_state(cmd_runner, venv) == _state(additional_deps) and
language.healthy(cmd_runner, language_version)
_read_state(prefix, venv) == _state(additional_deps) and
language.healthy(prefix, language_version)
)
)
def _install_all(venvs, repo_url, store):
"""Tuple of (cmd_runner, language, version, deps)"""
"""Tuple of (prefix, language, version, deps)"""
def _need_installed():
return tuple(
(cmd_runner, language_name, version, deps)
for cmd_runner, language_name, version, deps in venvs
if not _installed(cmd_runner, language_name, version, deps)
(prefix, language_name, version, deps)
for prefix, language_name, version, deps in venvs
if not _installed(prefix, language_name, version, deps)
)
if not _need_installed():
@@ -90,19 +90,19 @@ def _install_all(venvs, repo_url, store):
logger.info('Once installed this environment will be reused.')
logger.info('This may take a few minutes...')
for cmd_runner, language_name, version, deps in need_installed:
for prefix, language_name, version, deps in need_installed:
language = languages[language_name]
venv = environment_dir(language.ENVIRONMENT_DIR, version)
# There's potentially incomplete cleanup from previous runs
# Clean it up!
if cmd_runner.exists(venv):
shutil.rmtree(cmd_runner.path(venv))
if prefix.exists(venv):
shutil.rmtree(prefix.path(venv))
language.install_environment(cmd_runner, version, deps)
language.install_environment(prefix, version, deps)
# Write our state to indicate we're installed
state = _state(deps)
_write_state(cmd_runner, venv, state)
_write_state(prefix, venv, state)
def _hook(*hook_dicts):
@@ -156,11 +156,11 @@ class Repository(object):
)
@cached_property
def _cmd_runner(self):
return PrefixedCommandRunner(self._repo_path)
def _prefix(self):
return Prefix(self._repo_path)
def _cmd_runner_from_deps(self, language_name, deps):
return self._cmd_runner
def _prefix_from_deps(self, language_name, deps):
return self._prefix
@cached_property
def manifest_hooks(self):
@@ -194,7 +194,7 @@ class Repository(object):
)
ret = []
for (language, version), deps in deps_dict.items():
ret.append((self._cmd_runner, language, version, deps))
ret.append((self._prefix, language, version, deps))
return tuple(ret)
def require_installed(self):
@@ -211,20 +211,20 @@ class Repository(object):
self.require_installed()
language_name = hook['language']
deps = hook['additional_dependencies']
cmd_runner = self._cmd_runner_from_deps(language_name, deps)
return languages[language_name].run_hook(cmd_runner, hook, file_args)
prefix = self._prefix_from_deps(language_name, deps)
return languages[language_name].run_hook(prefix, hook, file_args)
class LocalRepository(Repository):
def _cmd_runner_from_deps(self, language_name, deps):
"""local repositories have a cmd runner per hook"""
def _prefix_from_deps(self, language_name, deps):
"""local repositories have a prefix per hook"""
language = languages[language_name]
# pcre / pygrep / script / system / docker_image do not have
# environments so they work out of the current directory
if language.ENVIRONMENT_DIR is None:
return PrefixedCommandRunner(git.get_root())
return Prefix(git.get_root())
else:
return PrefixedCommandRunner(self.store.make_local(deps))
return Prefix(self.store.make_local(deps))
@cached_property
def manifest(self):
@@ -245,7 +245,7 @@ class LocalRepository(Repository):
version = hook['language_version']
deps = hook['additional_dependencies']
ret.append((
self._cmd_runner_from_deps(language, deps),
self._prefix_from_deps(language, deps),
language, version, deps,
))
return tuple(ret)