third-party/pre-commit
1
0
Fork 0
mirror of https://github.com/pre-commit/pre-commit.git synced 2026-02-19 09:04:41 +04:00
Code Issues Projects Releases Packages Wiki Activity Actions

move clean_path_on_failure out of each hook install

Browse source
This commit is contained in:
Anthony Sottile 2023-01-01 19:46:17 -05:00
parent 0224be8194
commit d05b7888ab
15 changed files with 277 additions and 312 deletions
Download patch file Download diff file Expand all files Collapse all files

16
pre_commit/languages/conda.py
View file

@ -13,7 +13,6 @@ from pre_commit.envcontext import Var
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output_b from pre_commit.util import cmd_output_b
ENVIRONMENT_DIR = 'conda' ENVIRONMENT_DIR = 'conda'
@ -71,16 +70,15 @@ def install_environment(
conda_exe = _conda_exe() conda_exe = _conda_exe()
env_dir = prefix.path(directory) env_dir = prefix.path(directory)
with clean_path_on_failure(env_dir): cmd_output_b(
conda_exe, 'env', 'create', '-p', env_dir, '--file',
'environment.yml', cwd=prefix.prefix_dir,
)
if additional_dependencies:
cmd_output_b( cmd_output_b(
conda_exe, 'env', 'create', '-p', env_dir, '--file', conda_exe, 'install', '-p', env_dir, *additional_dependencies,
'environment.yml', cwd=prefix.prefix_dir, cwd=prefix.prefix_dir,
) )
if additional_dependencies:
cmd_output_b(
conda_exe, 'install', '-p', env_dir, *additional_dependencies,
cwd=prefix.prefix_dir,
)
def run_hook( def run_hook(

30
pre_commit/languages/coursier.py
View file

@ -12,7 +12,6 @@ from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.parse_shebang import find_executable from pre_commit.parse_shebang import find_executable
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
ENVIRONMENT_DIR = 'coursier' ENVIRONMENT_DIR = 'coursier'
@ -38,21 +37,20 @@ def install_environment(
envdir = prefix.path(helpers.environment_dir(ENVIRONMENT_DIR, version)) envdir = prefix.path(helpers.environment_dir(ENVIRONMENT_DIR, version))
channel = prefix.path('.pre-commit-channel') channel = prefix.path('.pre-commit-channel')
with clean_path_on_failure(envdir): for app_descriptor in os.listdir(channel):
for app_descriptor in os.listdir(channel): _, app_file = os.path.split(app_descriptor)
_, app_file = os.path.split(app_descriptor) app, _ = os.path.splitext(app_file)
app, _ = os.path.splitext(app_file) helpers.run_setup_cmd(
helpers.run_setup_cmd( prefix,
prefix, (
( executable,
executable, 'install',
'install', '--default-channels=false',
'--default-channels=false', f'--channel={channel}',
f'--channel={channel}', app,
app, f'--dir={envdir}',
f'--dir={envdir}', ),
), )
)
def get_env_patch(target_dir: str) -> PatchesT: # pragma: win32 no cover def get_env_patch(target_dir: str) -> PatchesT: # pragma: win32 no cover

56
pre_commit/languages/dart.py
View file

@ -14,7 +14,6 @@ from pre_commit.envcontext import Var
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import win_exe from pre_commit.util import win_exe
from pre_commit.util import yaml_load from pre_commit.util import yaml_load
@ -67,39 +66,38 @@ def install_environment(
env=dart_env, env=dart_env,
) )
with clean_path_on_failure(envdir): os.makedirs(bin_dir)
os.makedirs(bin_dir)
with tempfile.TemporaryDirectory() as tmp: with tempfile.TemporaryDirectory() as tmp:
_install_dir(prefix, tmp) _install_dir(prefix, tmp)
for dep_s in additional_dependencies: for dep_s in additional_dependencies:
with tempfile.TemporaryDirectory() as dep_tmp: with tempfile.TemporaryDirectory() as dep_tmp:
dep, _, version = dep_s.partition(':') dep, _, version = dep_s.partition(':')
if version: if version:
dep_cmd: tuple[str, ...] = (dep, '--version', version) dep_cmd: tuple[str, ...] = (dep, '--version', version)
else: else:
dep_cmd = (dep,) dep_cmd = (dep,)
helpers.run_setup_cmd( helpers.run_setup_cmd(
prefix, prefix,
('dart', 'pub', 'cache', 'add', *dep_cmd), ('dart', 'pub', 'cache', 'add', *dep_cmd),
env={**os.environ, 'PUB_CACHE': dep_tmp}, env={**os.environ, 'PUB_CACHE': dep_tmp},
)
# try and find the 'pubspec.yaml' that just got added
for root, _, filenames in os.walk(dep_tmp):
if 'pubspec.yaml' in filenames:
with tempfile.TemporaryDirectory() as copied:
pkg = os.path.join(copied, 'pkg')
shutil.copytree(root, pkg)
_install_dir(Prefix(pkg), dep_tmp)
break
else:
raise AssertionError(
f'could not find pubspec.yaml for {dep_s}',
) )
# try and find the 'pubspec.yaml' that just got added
for root, _, filenames in os.walk(dep_tmp):
if 'pubspec.yaml' in filenames:
with tempfile.TemporaryDirectory() as copied:
pkg = os.path.join(copied, 'pkg')
shutil.copytree(root, pkg)
_install_dir(Prefix(pkg), dep_tmp)
break
else:
raise AssertionError(
f'could not find pubspec.yaml for {dep_s}',
)
def run_hook( def run_hook(
hook: Hook, hook: Hook,

6
pre_commit/languages/docker.py
View file

@ -10,7 +10,6 @@ from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import CalledProcessError from pre_commit.util import CalledProcessError
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output_b from pre_commit.util import cmd_output_b
ENVIRONMENT_DIR = 'docker' ENVIRONMENT_DIR = 'docker'
@ -101,9 +100,8 @@ def install_environment(
# Docker doesn't really have relevant disk environment, but pre-commit # Docker doesn't really have relevant disk environment, but pre-commit
# still needs to cleanup its state files on failure # still needs to cleanup its state files on failure
with clean_path_on_failure(directory): build_docker_image(prefix, pull=True)
build_docker_image(prefix, pull=True) os.mkdir(directory)
os.mkdir(directory)
def get_docker_user() -> tuple[str, ...]: # pragma: win32 no cover def get_docker_user() -> tuple[str, ...]: # pragma: win32 no cover

88
pre_commit/languages/dotnet.py
View file

@ -16,7 +16,6 @@ from pre_commit.envcontext import Var
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
ENVIRONMENT_DIR = 'dotnetenv' ENVIRONMENT_DIR = 'dotnetenv'
BIN_DIR = 'bin' BIN_DIR = 'bin'
@ -64,59 +63,58 @@ def install_environment(
helpers.assert_no_additional_deps('dotnet', additional_dependencies) helpers.assert_no_additional_deps('dotnet', additional_dependencies)
envdir = prefix.path(helpers.environment_dir(ENVIRONMENT_DIR, version)) envdir = prefix.path(helpers.environment_dir(ENVIRONMENT_DIR, version))
with clean_path_on_failure(envdir): build_dir = 'pre-commit-build'
build_dir = 'pre-commit-build'
# Build & pack nupkg file # Build & pack nupkg file
helpers.run_setup_cmd( helpers.run_setup_cmd(
prefix, prefix,
( (
'dotnet', 'pack', 'dotnet', 'pack',
'--configuration', 'Release', '--configuration', 'Release',
'--output', build_dir, '--output', build_dir,
), ),
) )
nupkg_dir = prefix.path(build_dir) nupkg_dir = prefix.path(build_dir)
nupkgs = [x for x in os.listdir(nupkg_dir) if x.endswith('.nupkg')] nupkgs = [x for x in os.listdir(nupkg_dir) if x.endswith('.nupkg')]
if not nupkgs: if not nupkgs:
raise AssertionError('could not find any build outputs to install') raise AssertionError('could not find any build outputs to install')
for nupkg in nupkgs: for nupkg in nupkgs:
with zipfile.ZipFile(os.path.join(nupkg_dir, nupkg)) as f: with zipfile.ZipFile(os.path.join(nupkg_dir, nupkg)) as f:
nuspec, = (x for x in f.namelist() if x.endswith('.nuspec')) nuspec, = (x for x in f.namelist() if x.endswith('.nuspec'))
with f.open(nuspec) as spec: with f.open(nuspec) as spec:
tree = xml.etree.ElementTree.parse(spec) tree = xml.etree.ElementTree.parse(spec)
namespace = re.match(r'{.*}', tree.getroot().tag) namespace = re.match(r'{.*}', tree.getroot().tag)
if not namespace: if not namespace:
raise AssertionError('could not parse namespace from nuspec') raise AssertionError('could not parse namespace from nuspec')
tool_id_element = tree.find(f'.//{namespace[0]}id') tool_id_element = tree.find(f'.//{namespace[0]}id')
if tool_id_element is None: if tool_id_element is None:
raise AssertionError('expected to find an "id" element') raise AssertionError('expected to find an "id" element')
tool_id = tool_id_element.text tool_id = tool_id_element.text
if not tool_id: if not tool_id:
raise AssertionError('"id" element missing tool name') raise AssertionError('"id" element missing tool name')
# Install to bin dir # Install to bin dir
with _nuget_config_no_sources() as nuget_config: with _nuget_config_no_sources() as nuget_config:
helpers.run_setup_cmd( helpers.run_setup_cmd(
prefix, prefix,
( (
'dotnet', 'tool', 'install', 'dotnet', 'tool', 'install',
'--configfile', nuget_config, '--configfile', nuget_config,
'--tool-path', os.path.join(envdir, BIN_DIR), '--tool-path', os.path.join(envdir, BIN_DIR),
'--add-source', build_dir, '--add-source', build_dir,
tool_id, tool_id,
), ),
) )
# Clean the git dir, ignoring the environment dir # Clean the git dir, ignoring the environment dir
clean_cmd = ('git', 'clean', '-ffxd', '-e', f'{ENVIRONMENT_DIR}-*') clean_cmd = ('git', 'clean', '-ffxd', '-e', f'{ENVIRONMENT_DIR}-*')
helpers.run_setup_cmd(prefix, clean_cmd) helpers.run_setup_cmd(prefix, clean_cmd)
def run_hook( def run_hook(

46
pre_commit/languages/golang.py
View file

@ -14,7 +14,6 @@ from pre_commit.envcontext import Var
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output from pre_commit.util import cmd_output
from pre_commit.util import cmd_output_b from pre_commit.util import cmd_output_b
from pre_commit.util import rmtree from pre_commit.util import rmtree
@ -65,31 +64,30 @@ def install_environment(
helpers.environment_dir(ENVIRONMENT_DIR, C.DEFAULT), helpers.environment_dir(ENVIRONMENT_DIR, C.DEFAULT),
) )
with clean_path_on_failure(directory): remote = git.get_remote_url(prefix.prefix_dir)
remote = git.get_remote_url(prefix.prefix_dir) repo_src_dir = os.path.join(directory, 'src', guess_go_dir(remote))
repo_src_dir = os.path.join(directory, 'src', guess_go_dir(remote))
# Clone into the goenv we'll create # Clone into the goenv we'll create
cmd = ('git', 'clone', '--recursive', '.', repo_src_dir) cmd = ('git', 'clone', '--recursive', '.', repo_src_dir)
helpers.run_setup_cmd(prefix, cmd) helpers.run_setup_cmd(prefix, cmd)
if sys.platform == 'cygwin': # pragma: no cover if sys.platform == 'cygwin': # pragma: no cover
_, gopath, _ = cmd_output('cygpath', '-w', directory) _, gopath, _ = cmd_output('cygpath', '-w', directory)
gopath = gopath.strip() gopath = gopath.strip()
else: else:
gopath = directory gopath = directory
env = dict(os.environ, GOPATH=gopath) env = dict(os.environ, GOPATH=gopath)
env.pop('GOBIN', None) env.pop('GOBIN', None)
cmd_output_b('go', 'install', './...', cwd=repo_src_dir, env=env) cmd_output_b('go', 'install', './...', cwd=repo_src_dir, env=env)
for dependency in additional_dependencies: for dependency in additional_dependencies:
cmd_output_b( cmd_output_b(
'go', 'install', dependency, cwd=repo_src_dir, env=env, 'go', 'install', dependency, cwd=repo_src_dir, env=env,
) )
# Same some disk space, we don't need these after installation # Same some disk space, we don't need these after installation
rmtree(prefix.path(directory, 'src')) rmtree(prefix.path(directory, 'src'))
pkgdir = prefix.path(directory, 'pkg') pkgdir = prefix.path(directory, 'pkg')
if os.path.exists(pkgdir): # pragma: no cover (go<1.10) if os.path.exists(pkgdir): # pragma: no cover (go<1.10)
rmtree(pkgdir) rmtree(pkgdir)
def run_hook( def run_hook(

28
pre_commit/languages/lua.py
View file

@ -13,7 +13,6 @@ from pre_commit.envcontext import Var
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output from pre_commit.util import cmd_output
ENVIRONMENT_DIR = 'lua_env' ENVIRONMENT_DIR = 'lua_env'
@ -64,22 +63,21 @@ def install_environment(
helpers.assert_version_default('lua', version) helpers.assert_version_default('lua', version)
envdir = _envdir(prefix) envdir = _envdir(prefix)
with clean_path_on_failure(envdir): with in_env(prefix):
with in_env(prefix): # luarocks doesn't bootstrap a tree prior to installing
# luarocks doesn't bootstrap a tree prior to installing # so ensure the directory exists.
# so ensure the directory exists. os.makedirs(envdir, exist_ok=True)
os.makedirs(envdir, exist_ok=True)
# Older luarocks (e.g., 2.4.2) expect the rockspec as an arg # Older luarocks (e.g., 2.4.2) expect the rockspec as an arg
for rockspec in prefix.star('.rockspec'): for rockspec in prefix.star('.rockspec'):
make_cmd = ('luarocks', '--tree', envdir, 'make', rockspec) make_cmd = ('luarocks', '--tree', envdir, 'make', rockspec)
helpers.run_setup_cmd(prefix, make_cmd) helpers.run_setup_cmd(prefix, make_cmd)
# luarocks can't install multiple packages at once # luarocks can't install multiple packages at once
# so install them individually. # so install them individually.
for dependency in additional_dependencies: for dependency in additional_dependencies:
cmd = ('luarocks', '--tree', envdir, 'install', dependency) cmd = ('luarocks', '--tree', envdir, 'install', dependency)
helpers.run_setup_cmd(prefix, cmd) helpers.run_setup_cmd(prefix, cmd)
def run_hook( def run_hook(

45
pre_commit/languages/node.py
View file

@ -16,7 +16,6 @@ from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.languages.python import bin_dir from pre_commit.languages.python import bin_dir
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output from pre_commit.util import cmd_output
from pre_commit.util import cmd_output_b from pre_commit.util import cmd_output_b
from pre_commit.util import rmtree from pre_commit.util import rmtree
@ -85,41 +84,37 @@ def health_check(prefix: Prefix, language_version: str) -> str | None:
def install_environment( def install_environment(
prefix: Prefix, version: str, additional_dependencies: Sequence[str], prefix: Prefix, version: str, additional_dependencies: Sequence[str],
) -> None: ) -> None:
additional_dependencies = tuple(additional_dependencies)
assert prefix.exists('package.json') assert prefix.exists('package.json')
envdir = _envdir(prefix, version) envdir = _envdir(prefix, version)
# https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx?f=255&MSPPError=-2147217396#maxpath # https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx?f=255&MSPPError=-2147217396#maxpath
if sys.platform == 'win32': # pragma: no cover if sys.platform == 'win32': # pragma: no cover
envdir = fr'\\?\{os.path.normpath(envdir)}' envdir = fr'\\?\{os.path.normpath(envdir)}'
with clean_path_on_failure(envdir): cmd = [sys.executable, '-mnodeenv', '--prebuilt', '--clean-src', envdir]
cmd = [ if version != C.DEFAULT:
sys.executable, '-mnodeenv', '--prebuilt', '--clean-src', envdir, cmd.extend(['-n', version])
] cmd_output_b(*cmd)
if version != C.DEFAULT:
cmd.extend(['-n', version])
cmd_output_b(*cmd)
with in_env(prefix, version): with in_env(prefix, version):
# https://npm.community/t/npm-install-g-git-vs-git-clone-cd-npm-install-g/5449 # https://npm.community/t/npm-install-g-git-vs-git-clone-cd-npm-install-g/5449
# install as if we installed from git # install as if we installed from git
local_install_cmd = ( local_install_cmd = (
'npm', 'install', '--dev', '--prod', 'npm', 'install', '--dev', '--prod',
'--ignore-prepublish', '--no-progress', '--no-save', '--ignore-prepublish', '--no-progress', '--no-save',
) )
helpers.run_setup_cmd(prefix, local_install_cmd) helpers.run_setup_cmd(prefix, local_install_cmd)
_, pkg, _ = cmd_output('npm', 'pack', cwd=prefix.prefix_dir) _, pkg, _ = cmd_output('npm', 'pack', cwd=prefix.prefix_dir)
pkg = prefix.path(pkg.strip()) pkg = prefix.path(pkg.strip())
install = ('npm', 'install', '-g', pkg, *additional_dependencies) install = ('npm', 'install', '-g', pkg, *additional_dependencies)
helpers.run_setup_cmd(prefix, install) helpers.run_setup_cmd(prefix, install)
# clean these up after installation # clean these up after installation
if prefix.exists('node_modules'): # pragma: win32 no cover if prefix.exists('node_modules'): # pragma: win32 no cover
rmtree(prefix.path('node_modules')) rmtree(prefix.path('node_modules'))
os.remove(pkg) os.remove(pkg)
def run_hook( def run_hook(

10
pre_commit/languages/perl.py
View file

@ -12,7 +12,6 @@ from pre_commit.envcontext import Var
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
ENVIRONMENT_DIR = 'perl_env' ENVIRONMENT_DIR = 'perl_env'
get_default_version = helpers.basic_get_default_version get_default_version = helpers.basic_get_default_version
@ -52,11 +51,10 @@ def install_environment(
) -> None: ) -> None:
helpers.assert_version_default('perl', version) helpers.assert_version_default('perl', version)
with clean_path_on_failure(_envdir(prefix, version)): with in_env(prefix, version):
with in_env(prefix, version): helpers.run_setup_cmd(
helpers.run_setup_cmd( prefix, ('cpan', '-T', '.', *additional_dependencies),
prefix, ('cpan', '-T', '.', *additional_dependencies), )
)
def run_hook( def run_hook(

8
pre_commit/languages/python.py
View file

@ -17,7 +17,6 @@ from pre_commit.languages import helpers
from pre_commit.parse_shebang import find_executable from pre_commit.parse_shebang import find_executable
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import CalledProcessError 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 cmd_output
from pre_commit.util import cmd_output_b from pre_commit.util import cmd_output_b
from pre_commit.util import win_exe from pre_commit.util import win_exe
@ -215,10 +214,9 @@ def install_environment(
venv_cmd.extend(('-p', python)) venv_cmd.extend(('-p', python))
install_cmd = ('python', '-mpip', 'install', '.', *additional_dependencies) install_cmd = ('python', '-mpip', 'install', '.', *additional_dependencies)
with clean_path_on_failure(envdir): cmd_output_b(*venv_cmd, cwd='/')
cmd_output_b(*venv_cmd, cwd='/') with in_env(prefix, version):
with in_env(prefix, version): helpers.run_setup_cmd(prefix, install_cmd)
helpers.run_setup_cmd(prefix, install_cmd)
def run_hook( def run_hook(

92
pre_commit/languages/r.py
View file

@ -13,7 +13,6 @@ from pre_commit.envcontext import UNSET
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output_b from pre_commit.util import cmd_output_b
from pre_commit.util import win_exe from pre_commit.util import win_exe
@ -95,54 +94,53 @@ def install_environment(
additional_dependencies: Sequence[str], additional_dependencies: Sequence[str],
) -> None: ) -> None:
env_dir = _get_env_dir(prefix, version) env_dir = _get_env_dir(prefix, version)
with clean_path_on_failure(env_dir): os.makedirs(env_dir, exist_ok=True)
os.makedirs(env_dir, exist_ok=True) shutil.copy(prefix.path('renv.lock'), env_dir)
shutil.copy(prefix.path('renv.lock'), env_dir) shutil.copytree(prefix.path('renv'), os.path.join(env_dir, 'renv'))
shutil.copytree(prefix.path('renv'), os.path.join(env_dir, 'renv'))
r_code_inst_environment = f"""\ r_code_inst_environment = f"""\
prefix_dir <- {prefix.prefix_dir!r} prefix_dir <- {prefix.prefix_dir!r}
options( options(
repos = c(CRAN = "https://cran.rstudio.com"), repos = c(CRAN = "https://cran.rstudio.com"),
renv.consent = TRUE renv.consent = TRUE
)
source("renv/activate.R")
renv::restore()
activate_statement <- paste0(
'suppressWarnings({{',
'old <- setwd("', getwd(), '"); ',
'source("renv/activate.R"); ',
'setwd(old); ',
'renv::load("', getwd(), '");}})'
)
writeLines(activate_statement, 'activate.R')
is_package <- tryCatch(
{{
path_desc <- file.path(prefix_dir, 'DESCRIPTION')
suppressWarnings(desc <- read.dcf(path_desc))
"Package" %in% colnames(desc)
}},
error = function(...) FALSE
)
if (is_package) {{
renv::install(prefix_dir)
}}
"""
cmd_output_b(
_rscript_exec(), '--vanilla', '-e',
_inline_r_setup(r_code_inst_environment),
cwd=env_dir,
) )
if additional_dependencies: source("renv/activate.R")
r_code_inst_add = 'renv::install(commandArgs(trailingOnly = TRUE))' renv::restore()
with in_env(prefix, version): activate_statement <- paste0(
cmd_output_b( 'suppressWarnings({{',
_rscript_exec(), *RSCRIPT_OPTS, '-e', 'old <- setwd("', getwd(), '"); ',
_inline_r_setup(r_code_inst_add), 'source("renv/activate.R"); ',
*additional_dependencies, 'setwd(old); ',
cwd=env_dir, 'renv::load("', getwd(), '");}})'
) )
writeLines(activate_statement, 'activate.R')
is_package <- tryCatch(
{{
path_desc <- file.path(prefix_dir, 'DESCRIPTION')
suppressWarnings(desc <- read.dcf(path_desc))
"Package" %in% colnames(desc)
}},
error = function(...) FALSE
)
if (is_package) {{
renv::install(prefix_dir)
}}
"""
cmd_output_b(
_rscript_exec(), '--vanilla', '-e',
_inline_r_setup(r_code_inst_environment),
cwd=env_dir,
)
if additional_dependencies:
r_code_inst_add = 'renv::install(commandArgs(trailingOnly = TRUE))'
with in_env(prefix, version):
cmd_output_b(
_rscript_exec(), *RSCRIPT_OPTS, '-e',
_inline_r_setup(r_code_inst_add),
*additional_dependencies,
cwd=env_dir,
)
def _inline_r_setup(code: str) -> str: def _inline_r_setup(code: str) -> str:

50
pre_commit/languages/ruby.py
View file

@ -17,7 +17,6 @@ from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import CalledProcessError from pre_commit.util import CalledProcessError
from pre_commit.util import clean_path_on_failure
from pre_commit.util import resource_bytesio from pre_commit.util import resource_bytesio
ENVIRONMENT_DIR = 'rbenv' ENVIRONMENT_DIR = 'rbenv'
@ -115,33 +114,30 @@ def _install_ruby(
def install_environment( def install_environment(
prefix: Prefix, version: str, additional_dependencies: Sequence[str], prefix: Prefix, version: str, additional_dependencies: Sequence[str],
) -> None: ) -> None:
additional_dependencies = tuple(additional_dependencies) if version != 'system': # pragma: win32 no cover
directory = helpers.environment_dir(ENVIRONMENT_DIR, version) _install_rbenv(prefix, version)
with clean_path_on_failure(prefix.path(directory)):
if version != 'system': # pragma: win32 no cover
_install_rbenv(prefix, version)
with in_env(prefix, version):
# Need to call this before installing so rbenv's directories
# are set up
helpers.run_setup_cmd(prefix, ('rbenv', 'init', '-'))
if version != C.DEFAULT:
_install_ruby(prefix, version)
# Need to call this after installing to set up the shims
helpers.run_setup_cmd(prefix, ('rbenv', 'rehash'))
with in_env(prefix, version): with in_env(prefix, version):
helpers.run_setup_cmd( # Need to call this before installing so rbenv's directories
prefix, ('gem', 'build', *prefix.star('.gemspec')), # are set up
) helpers.run_setup_cmd(prefix, ('rbenv', 'init', '-'))
helpers.run_setup_cmd( if version != C.DEFAULT:
prefix, _install_ruby(prefix, version)
( # Need to call this after installing to set up the shims
'gem', 'install', helpers.run_setup_cmd(prefix, ('rbenv', 'rehash'))
'--no-document', '--no-format-executable',
'--no-user-install', with in_env(prefix, version):
*prefix.star('.gem'), *additional_dependencies, helpers.run_setup_cmd(
), prefix, ('gem', 'build', *prefix.star('.gemspec')),
) )
helpers.run_setup_cmd(
prefix,
(
'gem', 'install',
'--no-document', '--no-format-executable',
'--no-user-install',
*prefix.star('.gem'), *additional_dependencies,
),
)
def run_hook( def run_hook(

38
pre_commit/languages/rust.py
View file

@ -18,7 +18,6 @@ from pre_commit.envcontext import Var
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output_b from pre_commit.util import cmd_output_b
from pre_commit.util import make_executable from pre_commit.util import make_executable
from pre_commit.util import win_exe from pre_commit.util import win_exe
@ -143,28 +142,27 @@ def install_environment(
} }
lib_deps = set(additional_dependencies) - cli_deps lib_deps = set(additional_dependencies) - cli_deps
with clean_path_on_failure(directory): packages_to_install: set[tuple[str, ...]] = {('--path', '.')}
packages_to_install: set[tuple[str, ...]] = {('--path', '.')} for cli_dep in cli_deps:
for cli_dep in cli_deps: cli_dep = cli_dep[len('cli:'):]
cli_dep = cli_dep[len('cli:'):] package, _, crate_version = cli_dep.partition(':')
package, _, crate_version = cli_dep.partition(':') if crate_version != '':
if crate_version != '': packages_to_install.add((package, '--version', crate_version))
packages_to_install.add((package, '--version', crate_version)) else:
else: packages_to_install.add((package,))
packages_to_install.add((package,))
with in_env(prefix, version): with in_env(prefix, version):
if version != 'system': if version != 'system':
install_rust_with_toolchain(_rust_toolchain(version)) install_rust_with_toolchain(_rust_toolchain(version))
if len(lib_deps) > 0: if len(lib_deps) > 0:
_add_dependencies(prefix, lib_deps) _add_dependencies(prefix, lib_deps)
for args in packages_to_install: for args in packages_to_install:
cmd_output_b( cmd_output_b(
'cargo', 'install', '--bins', '--root', directory, *args, 'cargo', 'install', '--bins', '--root', directory, *args,
cwd=prefix.prefix_dir, cwd=prefix.prefix_dir,
) )
def run_hook( def run_hook(

16
pre_commit/languages/swift.py
View file

@ -12,7 +12,6 @@ from pre_commit.envcontext import Var
from pre_commit.hook import Hook from pre_commit.hook import Hook
from pre_commit.languages import helpers from pre_commit.languages import helpers
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output_b from pre_commit.util import cmd_output_b
ENVIRONMENT_DIR = 'swift_env' ENVIRONMENT_DIR = 'swift_env'
@ -46,14 +45,13 @@ def install_environment(
) )
# Build the swift package # Build the swift package
with clean_path_on_failure(directory): os.mkdir(directory)
os.mkdir(directory) cmd_output_b(
cmd_output_b( 'swift', 'build',
'swift', 'build', '-C', prefix.prefix_dir,
'-C', prefix.prefix_dir, '-c', BUILD_CONFIG,
'-c', BUILD_CONFIG, '--build-path', os.path.join(directory, BUILD_DIR),
'--build-path', os.path.join(directory, BUILD_DIR), )
)
def run_hook( def run_hook(

60
pre_commit/repository.py
View file

@ -16,6 +16,7 @@ from pre_commit.languages.all import languages
from pre_commit.languages.helpers import environment_dir from pre_commit.languages.helpers import environment_dir
from pre_commit.prefix import Prefix from pre_commit.prefix import Prefix
from pre_commit.store import Store from pre_commit.store import Store
from pre_commit.util import clean_path_on_failure
from pre_commit.util import rmtree from pre_commit.util import rmtree
@ -26,12 +27,12 @@ def _state(additional_deps: Sequence[str]) -> object:
return {'additional_dependencies': sorted(additional_deps)} return {'additional_dependencies': sorted(additional_deps)}
def _state_filename(prefix: Prefix, venv: str) -> str: def _state_filename(venv: str) -> str:
return prefix.path(venv, f'.install_state_v{C.INSTALLED_STATE_VERSION}') return os.path.join(venv, f'.install_state_v{C.INSTALLED_STATE_VERSION}')
def _read_state(prefix: Prefix, venv: str) -> object | None: def _read_state(venv: str) -> object | None:
filename = _state_filename(prefix, venv) filename = _state_filename(venv)
if not os.path.exists(filename): if not os.path.exists(filename):
return None return None
else: else:
@ -39,26 +40,15 @@ def _read_state(prefix: Prefix, venv: str) -> object | None:
return json.load(f) return json.load(f)
def _write_state(prefix: Prefix, venv: str, state: object) -> None:
state_filename = _state_filename(prefix, venv)
staging = f'{state_filename}staging'
with open(staging, 'w') as state_file:
state_file.write(json.dumps(state))
# Move the file into place atomically to indicate we've installed
os.replace(staging, state_filename)
def _hook_installed(hook: Hook) -> bool: def _hook_installed(hook: Hook) -> bool:
lang = languages[hook.language] lang = languages[hook.language]
if lang.ENVIRONMENT_DIR is None: if lang.ENVIRONMENT_DIR is None:
return True return True
venv = environment_dir(lang.ENVIRONMENT_DIR, hook.language_version) venv = environment_dir(lang.ENVIRONMENT_DIR, hook.language_version)
venv = hook.prefix.path(venv)
return ( return (
( _read_state(venv) == _state(hook.additional_dependencies) and
_read_state(hook.prefix, venv) ==
_state(hook.additional_dependencies)
) and
not lang.health_check(hook.prefix, hook.language_version) not lang.health_check(hook.prefix, hook.language_version)
) )
@ -70,26 +60,34 @@ def _hook_install(hook: Hook) -> None:
lang = languages[hook.language] lang = languages[hook.language]
assert lang.ENVIRONMENT_DIR is not None assert lang.ENVIRONMENT_DIR is not None
venv = environment_dir(lang.ENVIRONMENT_DIR, hook.language_version) venv = environment_dir(lang.ENVIRONMENT_DIR, hook.language_version)
venv = hook.prefix.path(venv)
# There's potentially incomplete cleanup from previous runs # There's potentially incomplete cleanup from previous runs
# Clean it up! # Clean it up!
if hook.prefix.exists(venv): if os.path.exists(venv):
rmtree(hook.prefix.path(venv)) rmtree(venv)
lang.install_environment( with clean_path_on_failure(venv):
hook.prefix, hook.language_version, hook.additional_dependencies, lang.install_environment(
) hook.prefix, hook.language_version, hook.additional_dependencies,
health_error = lang.health_check(hook.prefix, hook.language_version)
if health_error:
raise AssertionError(
f'BUG: expected environment for {hook.language} to be healthy '
f'immediately after install, please open an issue describing '
f'your environment\n\n'
f'more info:\n\n{health_error}',
) )
# Write our state to indicate we're installed health_error = lang.health_check(hook.prefix, hook.language_version)
_write_state(hook.prefix, venv, _state(hook.additional_dependencies)) if health_error:
raise AssertionError(
f'BUG: expected environment for {hook.language} to be healthy '
f'immediately after install, please open an issue describing '
f'your environment\n\n'
f'more info:\n\n{health_error}',
)
# Write our state to indicate we're installed
state_filename = _state_filename(venv)
staging = f'{state_filename}staging'
with open(staging, 'w') as state_file:
state_file.write(json.dumps(_state(hook.additional_dependencies)))
# Move the file into place atomically to indicate we've installed
os.replace(staging, state_filename)
def _hook( def _hook(