mirror/pre-commit
1
0
Fork 0
mirror of https://github.com/pre-commit/pre-commit.git synced 2026-01-13 12:30:08 -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)

6
tests/conftest.py
View File

@@ -14,7 +14,6 @@ import six
import pre_commit.constants as C
from pre_commit import output
from pre_commit.logging_handler import add_logging_handler
from pre_commit.prefixed_command_runner import PrefixedCommandRunner
from pre_commit.runner import Runner
from pre_commit.store import Store
from pre_commit.util import cmd_output
@@ -155,11 +154,6 @@ def store(tempdir_factory):
yield Store(os.path.join(tempdir_factory.get(), '.pre-commit'))
@pytest.yield_fixture
def cmd_runner(tempdir_factory):
yield PrefixedCommandRunner(tempdir_factory.get())
@pytest.yield_fixture
def runner_with_mocked_store(mock_out_store_directory):
yield Runner('/', C.CONFIG_FILE)

6
tests/languages/all_test.py
View File

@@ -11,7 +11,7 @@ from pre_commit.languages.all import languages
@pytest.mark.parametrize('language', all_languages)
def test_install_environment_argspec(language):
expected_argspec = inspect.ArgSpec(
args=['repo_cmd_runner', 'version', 'additional_dependencies'],
args=['prefix', 'version', 'additional_dependencies'],
varargs=None, keywords=None, defaults=None,
)
argspec = inspect.getargspec(languages[language].install_environment)
@@ -26,7 +26,7 @@ def test_ENVIRONMENT_DIR(language):
@pytest.mark.parametrize('language', all_languages)
def test_run_hook_argpsec(language):
expected_argspec = inspect.ArgSpec(
args=['repo_cmd_runner', 'hook', 'file_args'],
args=['prefix', 'hook', 'file_args'],
varargs=None, keywords=None, defaults=None,
)
argspec = inspect.getargspec(languages[language].run_hook)
@@ -45,7 +45,7 @@ def test_get_default_version_argspec(language):
@pytest.mark.parametrize('language', all_languages)
def test_healthy_argspec(language):
expected_argspec = inspect.ArgSpec(
args=['repo_cmd_runner', 'language_version'],
args=['prefix', 'language_version'],
varargs=None, keywords=None, defaults=None,
)
argspec = inspect.getargspec(languages[language].healthy)

39
tests/languages/ruby_test.py
View File

@@ -1,39 +1,42 @@
from __future__ import unicode_literals
import os.path
import pipes
from pre_commit.languages.ruby import _install_rbenv
from pre_commit.prefix import Prefix
from pre_commit.util import cmd_output
from testing.util import xfailif_windows_no_ruby
@xfailif_windows_no_ruby
def test_install_rbenv(cmd_runner):
_install_rbenv(cmd_runner)
def test_install_rbenv(tempdir_factory):
prefix = Prefix(tempdir_factory.get())
_install_rbenv(prefix)
# Should have created rbenv directory
assert os.path.exists(cmd_runner.path('rbenv-default'))
assert os.path.exists(prefix.path('rbenv-default'))
# We should have created our `activate` script
activate_path = cmd_runner.path('rbenv-default', 'bin', 'activate')
activate_path = prefix.path('rbenv-default', 'bin', 'activate')
assert os.path.exists(activate_path)
# Should be able to activate using our script and access rbenv
cmd_runner.run(
[
'bash',
'-c',
". '{prefix}rbenv-default/bin/activate' && rbenv --help",
],
cmd_output(
'bash', '-c',
'. {} && rbenv --help'.format(pipes.quote(prefix.path(
'rbenv-default', 'bin', 'activate',
))),
)
@xfailif_windows_no_ruby
def test_install_rbenv_with_version(cmd_runner):
_install_rbenv(cmd_runner, version='1.9.3p547')
def test_install_rbenv_with_version(tempdir_factory):
prefix = Prefix(tempdir_factory.get())
_install_rbenv(prefix, version='1.9.3p547')
# Should be able to activate and use rbenv install
cmd_runner.run(
[
'bash',
'-c',
". '{prefix}rbenv-1.9.3p547/bin/activate' && rbenv install --help",
],
cmd_output(
'bash', '-c',
'. {} && rbenv install --help'.format(pipes.quote(prefix.path(
'rbenv-1.9.3p547', 'bin', 'activate',
))),
)

57
tests/prefix_test.py Normal file
View File

@@ -0,0 +1,57 @@
from __future__ import unicode_literals
import os
import pytest
from pre_commit.prefix import Prefix
def norm_slash(*args):
return tuple(x.replace('/', os.sep) for x in args)
@pytest.mark.parametrize(
('input', 'expected_prefix'), (
norm_slash('.', './'),
norm_slash('foo', 'foo/'),
norm_slash('bar/', 'bar/'),
norm_slash('foo/bar', 'foo/bar/'),
norm_slash('foo/bar/', 'foo/bar/'),
),
)
def test_init_normalizes_path_endings(input, expected_prefix):
instance = Prefix(input)
assert instance.prefix_dir == expected_prefix
PATH_TESTS = (
norm_slash('foo', '', 'foo'),
norm_slash('foo', 'bar', 'foo/bar'),
norm_slash('foo/bar', '../baz', 'foo/baz'),
norm_slash('./', 'bar', 'bar'),
norm_slash('./', '', '.'),
norm_slash('/tmp/foo', '/tmp/bar', '/tmp/bar'),
)
@pytest.mark.parametrize(('prefix', 'path_end', 'expected_output'), PATH_TESTS)
def test_path(prefix, path_end, expected_output):
instance = Prefix(prefix)
ret = instance.path(path_end)
assert ret == expected_output
def test_path_multiple_args():
instance = Prefix('foo')
ret = instance.path('bar', 'baz')
assert ret == os.path.join('foo', 'bar', 'baz')
def test_exists_does_not_exist(tmpdir):
assert not Prefix(str(tmpdir)).exists('foo')
def test_exists_does_exist(tmpdir):
tmpdir.ensure('foo')
assert Prefix(str(tmpdir)).exists('foo')

133
tests/prefixed_command_runner_test.py
View File

@@ -1,133 +0,0 @@
from __future__ import unicode_literals
import os
import subprocess
import mock
import pytest
from pre_commit.prefixed_command_runner import PrefixedCommandRunner
from pre_commit.util import CalledProcessError
def norm_slash(input_tup):
return tuple(x.replace('/', os.sep) for x in input_tup)
def test_CalledProcessError_str():
error = CalledProcessError(
1, [str('git'), str('status')], 0, (str('stdout'), str('stderr')),
)
assert str(error) == (
"Command: ['git', 'status']\n"
"Return code: 1\n"
"Expected return code: 0\n"
"Output: \n"
" stdout\n"
"Errors: \n"
" stderr\n"
)
def test_CalledProcessError_str_nooutput():
error = CalledProcessError(
1, [str('git'), str('status')], 0, (str(''), str('')),
)
assert str(error) == (
"Command: ['git', 'status']\n"
"Return code: 1\n"
"Expected return code: 0\n"
"Output: (none)\n"
"Errors: (none)\n"
)
@pytest.fixture
def popen_mock():
popen = mock.Mock(spec=subprocess.Popen)
popen.return_value.communicate.return_value = (b'stdout', b'stderr')
return popen
@pytest.fixture
def makedirs_mock():
return mock.Mock(spec=os.makedirs)
@pytest.mark.parametrize(
('input', 'expected_prefix'), (
norm_slash(('.', './')),
norm_slash(('foo', 'foo/')),
norm_slash(('bar/', 'bar/')),
norm_slash(('foo/bar', 'foo/bar/')),
norm_slash(('foo/bar/', 'foo/bar/')),
),
)
def test_init_normalizes_path_endings(input, expected_prefix):
input = input.replace('/', os.sep)
expected_prefix = expected_prefix.replace('/', os.sep)
instance = PrefixedCommandRunner(input)
assert instance.prefix_dir == expected_prefix
def test_run_substitutes_prefix(popen_mock, makedirs_mock):
instance = PrefixedCommandRunner(
'prefix', popen=popen_mock, makedirs=makedirs_mock,
)
ret = instance.run(['{prefix}bar', 'baz'], retcode=None)
popen_mock.assert_called_once_with(
(str(os.path.join('prefix', 'bar')), str('baz')),
env=None,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
assert ret == (popen_mock.return_value.returncode, 'stdout', 'stderr')
PATH_TESTS = (
norm_slash(('foo', '', 'foo')),
norm_slash(('foo', 'bar', 'foo/bar')),
norm_slash(('foo/bar', '../baz', 'foo/baz')),
norm_slash(('./', 'bar', 'bar')),
norm_slash(('./', '', '.')),
norm_slash(('/tmp/foo', '/tmp/bar', '/tmp/bar')),
)
@pytest.mark.parametrize(('prefix', 'path_end', 'expected_output'), PATH_TESTS)
def test_path(prefix, path_end, expected_output):
instance = PrefixedCommandRunner(prefix)
ret = instance.path(path_end)
assert ret == expected_output
def test_path_multiple_args():
instance = PrefixedCommandRunner('foo')
ret = instance.path('bar', 'baz')
assert ret == os.path.join('foo', 'bar', 'baz')
def test_create_path_if_not_exists(in_tmpdir):
instance = PrefixedCommandRunner('foo')
assert not os.path.exists('foo')
instance._create_path_if_not_exists()
assert os.path.exists('foo')
def test_exists_does_not_exist(in_tmpdir):
assert not PrefixedCommandRunner('.').exists('foo')
def test_exists_does_exist(in_tmpdir):
os.mkdir('foo')
assert PrefixedCommandRunner('.').exists('foo')
def test_raises_on_error(popen_mock, makedirs_mock):
popen_mock.return_value.returncode = 1
with pytest.raises(CalledProcessError):
instance = PrefixedCommandRunner(
'.', popen=popen_mock, makedirs=makedirs_mock,
)
instance.run(['echo'])

30
tests/repository_test.py
View File

@@ -191,7 +191,7 @@ def test_run_a_docker_image_hook(tempdir_factory, store, hook_id):
def test_run_a_node_hook(tempdir_factory, store):
_test_hook_repo(
tempdir_factory, store, 'node_hooks_repo',
'foo', ['/dev/null'], b'Hello World\n',
'foo', [os.devnull], b'Hello World\n',
)
@@ -200,7 +200,7 @@ def test_run_a_node_hook(tempdir_factory, store):
def test_run_versioned_node_hook(tempdir_factory, store):
_test_hook_repo(
tempdir_factory, store, 'node_0_11_8_hooks_repo',
'node-11-8-hook', ['/dev/null'], b'v0.11.8\nHello World\n',
'node-11-8-hook', [os.devnull], b'v0.11.8\nHello World\n',
)
@@ -209,7 +209,7 @@ def test_run_versioned_node_hook(tempdir_factory, store):
def test_run_a_ruby_hook(tempdir_factory, store):
_test_hook_repo(
tempdir_factory, store, 'ruby_hooks_repo',
'ruby_hook', ['/dev/null'], b'Hello world from a ruby hook\n',
'ruby_hook', [os.devnull], b'Hello world from a ruby hook\n',
)
@@ -219,7 +219,7 @@ def test_run_versioned_ruby_hook(tempdir_factory, store):
_test_hook_repo(
tempdir_factory, store, 'ruby_versioned_hooks_repo',
'ruby_hook',
['/dev/null'],
[os.devnull],
b'2.1.5\nHello world from a ruby hook\n',
)
@@ -242,7 +242,7 @@ def test_run_ruby_hook_with_disable_shared_gems(
_test_hook_repo(
tempdir_factory, store, 'ruby_versioned_hooks_repo',
'ruby_hook',
['/dev/null'],
[os.devnull],
b'2.1.5\nHello world from a ruby hook\n',
)
@@ -251,7 +251,7 @@ def test_run_ruby_hook_with_disable_shared_gems(
def test_system_hook_with_spaces(tempdir_factory, store):
_test_hook_repo(
tempdir_factory, store, 'system_hook_with_spaces_repo',
'system-hook-with-spaces', ['/dev/null'], b'Hello World\n',
'system-hook-with-spaces', [os.devnull], b'Hello World\n',
)
@@ -276,7 +276,7 @@ def test_golang_hook(tempdir_factory, store):
def test_missing_executable(tempdir_factory, store):
_test_hook_repo(
tempdir_factory, store, 'not_found_exe',
'not-found-exe', ['/dev/null'],
'not-found-exe', [os.devnull],
b'Executable `i-dont-exist-lol` not found',
expected_return_code=1,
)
@@ -424,7 +424,7 @@ def test_cwd_of_hook(tempdir_factory, store):
def test_lots_of_files(tempdir_factory, store):
_test_hook_repo(
tempdir_factory, store, 'script_hooks_repo',
'bash_hook', ['/dev/null'] * 15000, mock.ANY,
'bash_hook', [os.devnull] * 15000, mock.ANY,
)
@@ -467,7 +467,7 @@ def test_additional_python_dependencies_installed(tempdir_factory, store):
config['hooks'][0]['additional_dependencies'] = ['mccabe']
repo = Repository.create(config, store)
repo.require_installed()
with python.in_env(repo._cmd_runner, 'default'):
with python.in_env(repo._prefix, 'default'):
output = cmd_output('pip', 'freeze', '-l')[1]
assert 'mccabe' in output
@@ -484,7 +484,7 @@ def test_additional_dependencies_roll_forward(tempdir_factory, store):
repo = Repository.create(config, store)
repo.require_installed()
# We should see our additional dependency installed
with python.in_env(repo._cmd_runner, 'default'):
with python.in_env(repo._prefix, 'default'):
output = cmd_output('pip', 'freeze', '-l')[1]
assert 'mccabe' in output
@@ -499,7 +499,7 @@ def test_additional_ruby_dependencies_installed(
config['hooks'][0]['additional_dependencies'] = ['thread_safe', 'tins']
repo = Repository.create(config, store)
repo.require_installed()
with ruby.in_env(repo._cmd_runner, 'default'):
with ruby.in_env(repo._prefix, 'default'):
output = cmd_output('gem', 'list', '--local')[1]
assert 'thread_safe' in output
assert 'tins' in output
@@ -516,7 +516,7 @@ def test_additional_node_dependencies_installed(
config['hooks'][0]['additional_dependencies'] = ['lodash']
repo = Repository.create(config, store)
repo.require_installed()
with node.in_env(repo._cmd_runner, 'default'):
with node.in_env(repo._prefix, 'default'):
cmd_output('npm', 'config', 'set', 'global', 'true')
output = cmd_output('npm', 'ls')[1]
assert 'lodash' in output
@@ -533,7 +533,7 @@ def test_additional_golang_dependencies_installed(
config['hooks'][0]['additional_dependencies'] = deps
repo = Repository.create(config, store)
repo.require_installed()
binaries = os.listdir(repo._cmd_runner.path(
binaries = os.listdir(repo._prefix.path(
helpers.environment_dir(golang.ENVIRONMENT_DIR, 'default'), 'bin',
))
# normalize for windows
@@ -600,7 +600,7 @@ def test_control_c_control_c_on_install(tempdir_factory, store):
# Should have made an environment, however this environment is broken!
envdir = 'py_env-{}'.format(python.get_default_version())
assert repo._cmd_runner.exists(envdir)
assert repo._prefix.exists(envdir)
# However, it should be perfectly runnable (reinstall after botched
# install)
@@ -618,7 +618,7 @@ def test_invalidated_virtualenv(tempdir_factory, store):
# Simulate breaking of the virtualenv
repo.require_installed()
version = python.get_default_version()
libdir = repo._cmd_runner.path('py_env-{}'.format(version), 'lib', version)
libdir = repo._prefix.path('py_env-{}'.format(version), 'lib', version)
paths = [
os.path.join(libdir, p) for p in ('site.py', 'site.pyc', '__pycache__')
]

29
tests/util_test.py
View File

@@ -5,6 +5,7 @@ import random
import pytest
from pre_commit.util import CalledProcessError
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output
from pre_commit.util import cwd
@@ -12,6 +13,34 @@ from pre_commit.util import memoize_by_cwd
from pre_commit.util import tmpdir
def test_CalledProcessError_str():
error = CalledProcessError(
1, [str('git'), str('status')], 0, (str('stdout'), str('stderr')),
)
assert str(error) == (
"Command: ['git', 'status']\n"
"Return code: 1\n"
"Expected return code: 0\n"
"Output: \n"
" stdout\n"
"Errors: \n"
" stderr\n"
)
def test_CalledProcessError_str_nooutput():
error = CalledProcessError(
1, [str('git'), str('status')], 0, (str(''), str('')),
)
assert str(error) == (
"Command: ['git', 'status']\n"
"Return code: 1\n"
"Expected return code: 0\n"
"Output: (none)\n"
"Errors: (none)\n"
)
@pytest.fixture
def memoized_by_cwd():
@memoize_by_cwd