mirror/pre-commit
1
0
Fork 0
mirror of https://github.com/pre-commit/pre-commit.git synced 2026-01-14 04:50:20 -06:00
Code Issues Packages Projects Releases Wiki Activity

get lua version from luarocks itself

Browse Source
This commit is contained in:
Anthony Sottile
2022-01-17 15:46:36 -05:00
parent 3f8be7400d
commit 54331dca6f
3 changed files with 27 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
pre_commit/languages/lua.py
View File

@@ -1,6 +1,6 @@
import contextlib
import os
import re
import sys
from typing import Generator
from typing import Sequence
from typing import Tuple
@@ -11,7 +11,6 @@ from pre_commit.envcontext import PatchesT
from pre_commit.envcontext import Var
from pre_commit.hook import Hook
from pre_commit.languages import helpers
from pre_commit.parse_shebang import find_executable
from pre_commit.prefix import Prefix
from pre_commit.util import clean_path_on_failure
from pre_commit.util import cmd_output
@@ -21,95 +20,38 @@ get_default_version = helpers.basic_get_default_version
healthy = helpers.basic_healthy
def _find_lua(language_version: str) -> str: # pragma: win32 no cover
"""Find a lua executable.
Lua doesn't always have a plain `lua` executable.
Some OS vendors will ship the binary as `lua#.#` (e.g., lua5.3)
so discovery is needed to find a valid executable.
"""
if language_version == C.DEFAULT:
choices = ['lua']
for path in os.environ.get('PATH', '').split(os.pathsep):
try:
candidates = os.listdir(path)
except OSError:
# Invalid path on PATH or lacking permissions.
continue
for candidate in candidates:
# The Lua executable might look like `lua#.#` or `lua-#.#`.
if re.search(r'^lua[-]?\d+\.\d+', candidate):
choices.append(candidate)
else:
# Prefer version specific executables first if available.
# This should avoid the corner case where a user requests a language
# version, gets a `lua` executable, but that executable is actually
# for a different version and package.path would patch LUA_PATH
# incorrectly.
choices = [f'lua{language_version}', 'lua-{language_version}', 'lua']
found_exes = [exe for exe in choices if find_executable(exe)]
if found_exes:
return found_exes[0]
raise ValueError(
'No lua executable found on the system paths '
f'for {language_version} version.',
)
def _get_lua_path_version(
lua_executable: str,
) -> str: # pragma: win32 no cover
def _get_lua_version() -> str: # pragma: win32 no cover
"""Get the Lua version used in file paths."""
# This could sniff out from _VERSION, but checking package.path should
# provide an answer for *exactly* where lua is looking for packages.
_, stdout, _ = cmd_output(lua_executable, '-e', 'print(package.path)')
sep = os.sep if os.name != 'nt' else os.sep * 2
match = re.search(fr'{sep}lua{sep}(.*?){sep}', stdout)
if match:
return match[1]
raise ValueError('Cannot determine lua version for file paths.')
_, stdout, _ = cmd_output('luarocks', 'config', '--lua-ver')
return stdout.strip()
def get_env_patch(
env: str, language_version: str,
) -> PatchesT: # pragma: win32 no cover
lua = _find_lua(language_version)
version = _get_lua_path_version(lua)
def get_env_patch(d: str) -> PatchesT: # pragma: win32 no cover
version = _get_lua_version()
so_ext = 'dll' if sys.platform == 'win32' else 'so'
return (
('PATH', (os.path.join(env, 'bin'), os.pathsep, Var('PATH'))),
('PATH', (os.path.join(d, 'bin'), os.pathsep, Var('PATH'))),
(
'LUA_PATH', (
os.path.join(env, 'share', 'lua', version, '?.lua;'),
os.path.join(env, 'share', 'lua', version, '?', 'init.lua;;'),
os.path.join(d, 'share', 'lua', version, '?.lua;'),
os.path.join(d, 'share', 'lua', version, '?', 'init.lua;;'),
),
),
(
'LUA_CPATH', (
os.path.join(env, 'lib', 'lua', version, '?.so;;'),
),
'LUA_CPATH',
(os.path.join(d, 'lib', 'lua', version, f'?.{so_ext};;'),),
),
)
def _envdir(prefix: Prefix, version: str) -> str: # pragma: win32 no cover
directory = helpers.environment_dir(ENVIRONMENT_DIR, version)
def _envdir(prefix: Prefix) -> str: # pragma: win32 no cover
directory = helpers.environment_dir(ENVIRONMENT_DIR, C.DEFAULT)
return prefix.path(directory)
@contextlib.contextmanager # pragma: win32 no cover
def in_env(
prefix: Prefix,
language_version: str,
) -> Generator[None, None, None]:
with envcontext(
get_env_patch(
_envdir(prefix, language_version), language_version,
),
):
def in_env(prefix: Prefix) -> Generator[None, None, None]:
with envcontext(get_env_patch(_envdir(prefix))):
yield
@@ -120,19 +62,17 @@ def install_environment(
) -> None: # pragma: win32 no cover
helpers.assert_version_default('lua', version)
envdir = _envdir(prefix, version)
envdir = _envdir(prefix)
with clean_path_on_failure(envdir):
with in_env(prefix, version):
with in_env(prefix):
# luarocks doesn't bootstrap a tree prior to installing
# so ensure the directory exists.
os.makedirs(envdir, exist_ok=True)
make_cmd = ['luarocks', '--tree', envdir, 'make']
# Older luarocks (e.g., 2.4.2) expect the rockspec as an argument.
filenames = prefix.star('.rockspec')
make_cmd.extend(filenames[:1])
helpers.run_setup_cmd(prefix, tuple(make_cmd))
# Older luarocks (e.g., 2.4.2) expect the rockspec as an arg
for rockspec in prefix.star('.rockspec'):
make_cmd = ('luarocks', '--tree', envdir, 'make', rockspec)
helpers.run_setup_cmd(prefix, make_cmd)
# luarocks can't install multiple packages at once
# so install them individually.
@@ -146,5 +86,5 @@ def run_hook(
file_args: Sequence[str],
color: bool,
) -> Tuple[int, bytes]: # pragma: win32 no cover
with in_env(hook.prefix, hook.language_version):
with in_env(hook.prefix):
return helpers.run_xargs(hook, hook.cmd, file_args, color=color)

55
tests/languages/lua_test.py
View File

@@ -1,55 +0,0 @@
import os
from unittest import mock
import pytest
import pre_commit.constants as C
from pre_commit.languages import lua
from testing.util import xfailif_windows
@pytest.mark.parametrize(
'lua_name', ('lua', 'lua5.4', 'lua-5.4', 'lua5.4.exe'),
)
def test_find_lua(tmp_path, lua_name):
"""The language support can find common lua executable names."""
lua_file = tmp_path / lua_name
lua_file.touch(0o555)
with mock.patch.dict(os.environ, {'PATH': str(tmp_path)}):
lua_executable = lua._find_lua(C.DEFAULT)
assert lua_name in lua_executable
def test_find_lua_language_version(tmp_path):
"""Language discovery can find a specific version."""
lua_file = tmp_path / 'lua5.99'
lua_file.touch(0o555)
with mock.patch.dict(os.environ, {'PATH': str(tmp_path)}):
lua_executable = lua._find_lua('5.99')
assert 'lua5.99' in lua_executable
@pytest.mark.parametrize(
('invalid', 'mode'),
(
('foobar', 0o555),
('luac', 0o555),
# Windows doesn't respect the executable checking.
pytest.param('lua5.4', 0o444, marks=xfailif_windows),
),
)
def test_find_lua_fail(tmp_path, invalid, mode):
"""No lua executable on the system will fail."""
non_lua_file = tmp_path / invalid
non_lua_file.touch(mode)
with mock.patch.dict(os.environ, {'PATH': str(tmp_path)}):
with pytest.raises(ValueError):
lua._find_lua(C.DEFAULT)
@mock.patch.object(lua, 'cmd_output')
def test_bad_package_path(mock_cmd_output):
"""A package path missing path info returns an unknown version."""
mock_cmd_output.return_value = (0, '', '')
with pytest.raises(ValueError):
lua._get_lua_path_version('lua')

10
tests/repository_test.py
View File

@@ -17,7 +17,6 @@ from pre_commit.envcontext import envcontext
from pre_commit.hook import Hook
from pre_commit.languages import golang
from pre_commit.languages import helpers
from pre_commit.languages import lua
from pre_commit.languages import node
from pre_commit.languages import python
from pre_commit.languages import ruby
@@ -1142,18 +1141,17 @@ def test_lua_hook(tempdir_factory, store):
@skipif_cant_run_lua # pragma: win32 no cover
def test_local_lua_additional_dependencies(store):
lua_entry = lua._find_lua(C.DEFAULT)
config = {
'repo': 'local',
'hooks': [{
'id': 'local-lua',
'name': 'local-lua',
'entry': lua_entry,
'entry': 'luacheck --version',
'language': 'lua',
'args': ['-e', 'require "inspect"; print("hello world")'],
'additional_dependencies': ['inspect'],
'additional_dependencies': ['luacheck'],
}],
}
hook = _get_hook(config, store, 'local-lua')
ret, out = _hook_run(hook, (), color=False)
assert (ret, _norm_out(out)) == (0, b'hello world\n')
assert b'Luacheck' in out
assert ret == 0