Add naive and untested version of Lua language support.

azure-pipelines.yml

@@ -42,6 +42,8 @@ jobs:
       displayName: install coursier
     - bash: testing/get-dart.sh
       displayName: install dart
+    - bash: testing/get-lua.sh
+      displayName: install lua
     - bash: testing/get-swift.sh
       displayName: install swift
     - bash: testing/get-r.sh
@@ -56,6 +58,8 @@ jobs:
       displayName: install coursier
     - bash: testing/get-dart.sh
       displayName: install dart
+    - bash: testing/get-lua.sh
+      displayName: install lua
     - bash: testing/get-swift.sh
       displayName: install swift
     - bash: testing/get-r.sh

pre_commit/languages/all.py

@@ -13,6 +13,7 @@ from pre_commit.languages import docker_image
 from pre_commit.languages import dotnet
 from pre_commit.languages import fail
 from pre_commit.languages import golang
+from pre_commit.languages import lua
 from pre_commit.languages import node
 from pre_commit.languages import perl
 from pre_commit.languages import pygrep
@@ -51,6 +52,7 @@ languages = {
     'dotnet': Language(name='dotnet', ENVIRONMENT_DIR=dotnet.ENVIRONMENT_DIR, get_default_version=dotnet.get_default_version, healthy=dotnet.healthy, install_environment=dotnet.install_environment, run_hook=dotnet.run_hook),  # noqa: E501
     'fail': Language(name='fail', ENVIRONMENT_DIR=fail.ENVIRONMENT_DIR, get_default_version=fail.get_default_version, healthy=fail.healthy, install_environment=fail.install_environment, run_hook=fail.run_hook),  # noqa: E501
     'golang': Language(name='golang', ENVIRONMENT_DIR=golang.ENVIRONMENT_DIR, get_default_version=golang.get_default_version, healthy=golang.healthy, install_environment=golang.install_environment, run_hook=golang.run_hook),  # noqa: E501
+    'lua': Language(name='lua', ENVIRONMENT_DIR=lua.ENVIRONMENT_DIR, get_default_version=lua.get_default_version, healthy=lua.healthy, install_environment=lua.install_environment, run_hook=lua.run_hook),  # noqa: E501
     'node': Language(name='node', ENVIRONMENT_DIR=node.ENVIRONMENT_DIR, get_default_version=node.get_default_version, healthy=node.healthy, install_environment=node.install_environment, run_hook=node.run_hook),  # noqa: E501
     'perl': Language(name='perl', ENVIRONMENT_DIR=perl.ENVIRONMENT_DIR, get_default_version=perl.get_default_version, healthy=perl.healthy, install_environment=perl.install_environment, run_hook=perl.run_hook),  # noqa: E501
     'pygrep': Language(name='pygrep', ENVIRONMENT_DIR=pygrep.ENVIRONMENT_DIR, get_default_version=pygrep.get_default_version, healthy=pygrep.healthy, install_environment=pygrep.install_environment, run_hook=pygrep.run_hook),  # noqa: E501

pre_commit/languages/lua.py

@@ -0,0 +1,150 @@
+import contextlib
+import os
+import re
+from typing import Generator
+from typing import Sequence
+from typing import Tuple
+
+import pre_commit.constants as C
+from pre_commit.envcontext import envcontext
+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
+
+ENVIRONMENT_DIR = 'lua_env'
+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
+    """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.')
+
+
+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)
+    return (
+        ('PATH', (os.path.join(env, 'bin'), os.pathsep, Var('PATH'))),
+        (
+            'LUA_PATH', (
+                os.path.join(env, 'share', 'lua', version, '?.lua;'),
+                os.path.join(env, 'share', 'lua', version, '?', 'init.lua;;'),
+            ),
+        ),
+        (
+            'LUA_CPATH', (
+                os.path.join(env, 'lib', 'lua', version, '?.so;;'),
+            ),
+        ),
+    )
+
+
+def _envdir(prefix: Prefix, version: str) -> str:  # pragma: win32 no cover
+    directory = helpers.environment_dir(ENVIRONMENT_DIR, version)
+    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,
+        ),
+    ):
+        yield
+
+
+def install_environment(
+    prefix: Prefix,
+    version: str,
+    additional_dependencies: Sequence[str],
+) -> None:  # pragma: win32 no cover
+    helpers.assert_version_default('lua', version)
+
+    envdir = _envdir(prefix, version)
+    with clean_path_on_failure(envdir):
+        with in_env(prefix, version):
+            # 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))
+
+            # luarocks can't install multiple packages at once
+            # so install them individually.
+            for dependency in additional_dependencies:
+                cmd = ('luarocks', '--tree', envdir, 'install', dependency)
+                helpers.run_setup_cmd(prefix, cmd)
+
+
+def run_hook(
+    hook: Hook,
+    file_args: Sequence[str],
+    color: bool,
+) -> Tuple[int, bytes]:  # pragma: win32 no cover
+    with in_env(hook.prefix, hook.language_version):
+        return helpers.run_xargs(hook, hook.cmd, file_args, color=color)

pre_commit/resources/empty_template_pre-commit-package-dev-1.rockspec

@@ -0,0 +1,12 @@
+package = "pre-commit-package"
+version = "dev-1"
+
+source = {
+   url = "git+ssh://git@github.com/pre-commit/pre-commit.git"
+}
+description = {}
+dependencies = {}
+build = {
+    type = "builtin",
+    modules = {},
+}

pre_commit/store.py

@@ -188,7 +188,8 @@ class Store:
 
     LOCAL_RESOURCES = (
         'Cargo.toml', 'main.go', 'go.mod', 'main.rs', '.npmignore',
-        'package.json', 'pre_commit_placeholder_package.gemspec', 'setup.py',
+        'package.json', 'pre-commit-package-dev-1.rockspec',
+        'pre_commit_placeholder_package.gemspec', 'setup.py',
         'environment.yml', 'Makefile.PL', 'pubspec.yaml',
         'renv.lock', 'renv/activate.R', 'renv/LICENSE.renv',
     )

testing/gen-languages-all

@@ -3,7 +3,7 @@ import sys
 
 LANGUAGES = [
     'conda', 'coursier', 'dart', 'docker', 'docker_image', 'dotnet', 'fail',
-    'golang', 'node', 'perl', 'pygrep', 'python', 'r', 'ruby', 'rust',
+    'golang', 'lua', 'node', 'perl', 'pygrep', 'python', 'r', 'ruby', 'rust',
     'script', 'swift', 'system',
 ]
 FIELDS = [

testing/get-lua.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Install the runtime and package manager.
+sudo apt install lua5.3 liblua5.3-dev luarocks

testing/resources/lua_repo/.pre-commit-hooks.yaml

@@ -0,0 +1,4 @@
+-   id: hello-world-lua
+    name: hello world lua
+    entry: hello-world-lua
+    language: lua

testing/resources/lua_repo/bin/hello-world-lua

@@ -0,0 +1,3 @@
+#!/usr/bin/env lua
+
+print('hello world')

testing/resources/lua_repo/hello-dev-1.rockspec

@@ -0,0 +1,15 @@
+package = "hello"
+version = "dev-1"
+
+source = {
+   url = "git+ssh://git@github.com/pre-commit/pre-commit.git"
+}
+description = {}
+dependencies = {}
+build = {
+    type = "builtin",
+    modules = {},
+    install = {
+        bin = {"bin/hello-world-lua"}
+    },
+}

testing/util.py

@@ -48,6 +48,10 @@ skipif_cant_run_docker = pytest.mark.skipif(
     os.name == 'nt' or not docker_is_running(),
     reason="Docker isn't running or can't be accessed",
 )
+skipif_cant_run_lua = pytest.mark.skipif(
+    os.name == 'nt',
+    reason="lua isn't installed or can't be found",
+)
 skipif_cant_run_swift = pytest.mark.skipif(
     parse_shebang.find_executable('swift') is None,
     reason="swift isn't installed or can't be found",

tests/languages/lua_test.py

@@ -0,0 +1,55 @@
+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')

tests/repository_test.py

@@ -17,6 +17,7 @@ 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
@@ -34,6 +35,7 @@ from testing.util import cwd
 from testing.util import get_resource_path
 from testing.util import skipif_cant_run_coursier
 from testing.util import skipif_cant_run_docker
+from testing.util import skipif_cant_run_lua
 from testing.util import skipif_cant_run_swift
 from testing.util import xfailif_windows
 
@@ -1128,3 +1130,30 @@ def test_non_installable_hook_error_for_additional_dependencies(store, caplog):
         'using language `system` which does not install an environment.  '
         'Perhaps you meant to use a specific language?'
     )
+
+
+@skipif_cant_run_lua  # pragma: win32 no cover
+def test_lua_hook(tempdir_factory, store):
+    _test_hook_repo(
+        tempdir_factory, store, 'lua_repo',
+        'hello-world-lua', [], b'hello world\n',
+    )
+
+
+@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,
+            'language': 'lua',
+            'args': ['-e', 'require "inspect"; print("hello world")'],
+            'additional_dependencies': ['inspect'],
+        }],
+    }
+    hook = _get_hook(config, store, 'local-lua')
+    ret, out = _hook_run(hook, (), color=False)
+    assert (ret, _norm_out(out)) == (0, b'hello world\n')