Add naive and untested version of Lua language support.

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',
     )