pre-commit-ex 4.5.1__py2.py3-none-any.whl

pre_commit/languages/ruby.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import contextlib
+import functools
+import importlib.resources
+import os.path
+import shutil
+import tarfile
+from collections.abc import Generator
+from collections.abc import Sequence
+from typing import IO
+
+import pre_commit.constants as C
+from pre_commit import lang_base
+from pre_commit.envcontext import envcontext
+from pre_commit.envcontext import PatchesT
+from pre_commit.envcontext import UNSET
+from pre_commit.envcontext import Var
+from pre_commit.prefix import Prefix
+from pre_commit.util import CalledProcessError
+
+ENVIRONMENT_DIR = 'rbenv'
+health_check = lang_base.basic_health_check
+run_hook = lang_base.basic_run_hook
+
+
+def _resource_bytesio(filename: str) -> IO[bytes]:
+    files = importlib.resources.files('pre_commit.resources')
+    return files.joinpath(filename).open('rb')
+
+
+@functools.lru_cache(maxsize=1)
+def get_default_version() -> str:
+    if all(lang_base.exe_exists(exe) for exe in ('ruby', 'gem')):
+        return 'system'
+    else:
+        return C.DEFAULT
+
+
+def get_env_patch(
+        venv: str,
+        language_version: str,
+) -> PatchesT:
+    patches: PatchesT = (
+        ('GEM_HOME', os.path.join(venv, 'gems')),
+        ('GEM_PATH', UNSET),
+        ('BUNDLE_IGNORE_CONFIG', '1'),
+    )
+    if language_version == 'system':
+        patches += (
+            (
+                'PATH', (
+                    os.path.join(venv, 'gems', 'bin'), os.pathsep,
+                    Var('PATH'),
+                ),
+            ),
+        )
+    else:  # pragma: win32 no cover
+        patches += (
+            ('RBENV_ROOT', venv),
+            (
+                'PATH', (
+                    os.path.join(venv, 'gems', 'bin'), os.pathsep,
+                    os.path.join(venv, 'shims'), os.pathsep,
+                    os.path.join(venv, 'bin'), os.pathsep, Var('PATH'),
+                ),
+            ),
+        )
+    if language_version not in {'system', 'default'}:  # pragma: win32 no cover
+        patches += (('RBENV_VERSION', language_version),)
+
+    return patches
+
+
+@contextlib.contextmanager
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    with envcontext(get_env_patch(envdir, version)):
+        yield
+
+
+def _extract_resource(filename: str, dest: str) -> None:
+    with _resource_bytesio(filename) as bio:
+        with tarfile.open(fileobj=bio) as tf:
+            tf.extractall(dest)
+
+
+def _install_rbenv(
+        prefix: Prefix,
+        version: str,
+) -> None:  # pragma: win32 no cover
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+
+    _extract_resource('rbenv.tar.gz', prefix.path('.'))
+    shutil.move(prefix.path('rbenv'), envdir)
+
+    # Only install ruby-build if the version is specified
+    if version != C.DEFAULT:
+        plugins_dir = os.path.join(envdir, 'plugins')
+        _extract_resource('ruby-download.tar.gz', plugins_dir)
+        _extract_resource('ruby-build.tar.gz', plugins_dir)
+
+
+def _install_ruby(
+        prefix: Prefix,
+        version: str,
+) -> None:  # pragma: win32 no cover
+    try:
+        lang_base.setup_cmd(prefix, ('rbenv', 'download', version))
+    except CalledProcessError:  # pragma: no cover (usually find with download)
+        # Failed to download from mirror for some reason, build it instead
+        lang_base.setup_cmd(prefix, ('rbenv', 'install', version))
+
+
+def install_environment(
+        prefix: Prefix, version: str, additional_dependencies: Sequence[str],
+) -> None:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+
+    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
+            lang_base.setup_cmd(prefix, ('rbenv', 'init', '-'))
+            if version != C.DEFAULT:
+                _install_ruby(prefix, version)
+            # Need to call this after installing to set up the shims
+            lang_base.setup_cmd(prefix, ('rbenv', 'rehash'))
+
+    with in_env(prefix, version):
+        lang_base.setup_cmd(
+            prefix, ('gem', 'build', *prefix.star('.gemspec')),
+        )
+        lang_base.setup_cmd(
+            prefix,
+            (
+                'gem', 'install',
+                '--no-document', '--no-format-executable',
+                '--no-user-install',
+                '--install-dir', os.path.join(envdir, 'gems'),
+                '--bindir', os.path.join(envdir, 'gems', 'bin'),
+                *prefix.star('.gem'), *additional_dependencies,
+            ),
+        )

pre_commit/languages/rust.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import contextlib
+import functools
+import os.path
+import shutil
+import sys
+import tempfile
+import urllib.request
+from collections.abc import Generator
+from collections.abc import Sequence
+
+import pre_commit.constants as C
+from pre_commit import lang_base
+from pre_commit import parse_shebang
+from pre_commit.envcontext import envcontext
+from pre_commit.envcontext import PatchesT
+from pre_commit.envcontext import Var
+from pre_commit.prefix import Prefix
+from pre_commit.util import cmd_output_b
+from pre_commit.util import make_executable
+from pre_commit.util import win_exe
+
+ENVIRONMENT_DIR = 'rustenv'
+health_check = lang_base.basic_health_check
+run_hook = lang_base.basic_run_hook
+
+
+@functools.lru_cache(maxsize=1)
+def get_default_version() -> str:
+    # If rust is already installed, we can save a bunch of setup time by
+    # using the installed version.
+    #
+    # Just detecting the executable does not suffice, because if rustup is
+    # installed but no toolchain is available, then `cargo` exists but
+    # cannot be used without installing a toolchain first.
+    if cmd_output_b('cargo', '--version', check=False, cwd='/')[0] == 0:
+        return 'system'
+    else:
+        return C.DEFAULT
+
+
+def _rust_toolchain(language_version: str) -> str:
+    """Transform the language version into a rust toolchain version."""
+    if language_version == C.DEFAULT:
+        return 'stable'
+    else:
+        return language_version
+
+
+def get_env_patch(target_dir: str, version: str) -> PatchesT:
+    return (
+        ('PATH', (os.path.join(target_dir, 'bin'), os.pathsep, Var('PATH'))),
+        # Only set RUSTUP_TOOLCHAIN if we don't want use the system's default
+        # toolchain
+        *(
+            (('RUSTUP_TOOLCHAIN', _rust_toolchain(version)),)
+            if version != 'system' else ()
+        ),
+    )
+
+
+@contextlib.contextmanager
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    with envcontext(get_env_patch(envdir, version)):
+        yield
+
+
+def _add_dependencies(
+        prefix: Prefix,
+        additional_dependencies: set[str],
+) -> None:
+    crates = []
+    for dep in additional_dependencies:
+        name, _, spec = dep.partition(':')
+        crate = f'{name}@{spec or "*"}'
+        crates.append(crate)
+
+    lang_base.setup_cmd(prefix, ('cargo', 'add', *crates))
+
+
+def install_rust_with_toolchain(toolchain: str, envdir: str) -> None:
+    with tempfile.TemporaryDirectory() as rustup_dir:
+        with envcontext((('CARGO_HOME', envdir), ('RUSTUP_HOME', rustup_dir))):
+            # acquire `rustup` if not present
+            if parse_shebang.find_executable('rustup') is None:
+                # We did not detect rustup and need to download it first.
+                if sys.platform == 'win32':  # pragma: win32 cover
+                    url = 'https://win.rustup.rs/x86_64'
+                else:  # pragma: win32 no cover
+                    url = 'https://sh.rustup.rs'
+
+                resp = urllib.request.urlopen(url)
+
+                rustup_init = os.path.join(rustup_dir, win_exe('rustup-init'))
+                with open(rustup_init, 'wb') as f:
+                    shutil.copyfileobj(resp, f)
+                make_executable(rustup_init)
+
+                # install rustup into `$CARGO_HOME/bin`
+                cmd_output_b(
+                    rustup_init, '-y', '--quiet', '--no-modify-path',
+                    '--default-toolchain', 'none',
+                )
+
+            cmd_output_b(
+                'rustup', 'toolchain', 'install', '--no-self-update',
+                toolchain,
+            )
+
+
+def install_environment(
+        prefix: Prefix,
+        version: str,
+        additional_dependencies: Sequence[str],
+) -> None:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+
+    # There are two cases where we might want to specify more dependencies:
+    # as dependencies for the library being built, and as binary packages
+    # to be `cargo install`'d.
+    #
+    # Unlike e.g. Python, if we just `cargo install` a library, it won't be
+    # used for compilation. And if we add a crate providing a binary to the
+    # `Cargo.toml`, the binary won't be built.
+    #
+    # Because of this, we allow specifying "cli" dependencies by prefixing
+    # with 'cli:'.
+    cli_deps = {
+        dep for dep in additional_dependencies if dep.startswith('cli:')
+    }
+    lib_deps = set(additional_dependencies) - cli_deps
+
+    packages_to_install: set[tuple[str, ...]] = {('--path', '.')}
+    for cli_dep in cli_deps:
+        cli_dep = cli_dep.removeprefix('cli:')
+        package, _, crate_version = cli_dep.partition(':')
+        if crate_version != '':
+            packages_to_install.add((package, '--version', crate_version))
+        else:
+            packages_to_install.add((package,))
+
+    with contextlib.ExitStack() as ctx:
+        ctx.enter_context(in_env(prefix, version))
+
+        if version != 'system':
+            install_rust_with_toolchain(_rust_toolchain(version), envdir)
+
+            tmpdir = ctx.enter_context(tempfile.TemporaryDirectory())
+            ctx.enter_context(envcontext((('RUSTUP_HOME', tmpdir),)))
+
+        if len(lib_deps) > 0:
+            _add_dependencies(prefix, lib_deps)
+
+        for args in packages_to_install:
+            cmd_output_b(
+                'cargo', 'install', '--bins', '--root', envdir, *args,
+                cwd=prefix.prefix_dir,
+            )

pre_commit/languages/swift.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import contextlib
+import os
+from collections.abc import Generator
+from collections.abc import Sequence
+
+from pre_commit import lang_base
+from pre_commit.envcontext import envcontext
+from pre_commit.envcontext import PatchesT
+from pre_commit.envcontext import Var
+from pre_commit.prefix import Prefix
+from pre_commit.util import cmd_output_b
+
+BUILD_DIR = '.build'
+BUILD_CONFIG = 'release'
+
+ENVIRONMENT_DIR = 'swift_env'
+get_default_version = lang_base.basic_get_default_version
+health_check = lang_base.basic_health_check
+run_hook = lang_base.basic_run_hook
+
+
+def get_env_patch(venv: str) -> PatchesT:  # pragma: win32 no cover
+    bin_path = os.path.join(venv, BUILD_DIR, BUILD_CONFIG)
+    return (('PATH', (bin_path, os.pathsep, Var('PATH'))),)
+
+
+@contextlib.contextmanager  # pragma: win32 no cover
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    with envcontext(get_env_patch(envdir)):
+        yield
+
+
+def install_environment(
+        prefix: Prefix, version: str, additional_dependencies: Sequence[str],
+) -> None:  # pragma: win32 no cover
+    lang_base.assert_version_default('swift', version)
+    lang_base.assert_no_additional_deps('swift', additional_dependencies)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+
+    # Build the swift package
+    os.mkdir(envdir)
+    cmd_output_b(
+        'swift', 'build',
+        '--package-path', prefix.prefix_dir,
+        '-c', BUILD_CONFIG,
+        '--build-path', os.path.join(envdir, BUILD_DIR),
+    )

pre_commit/languages/unsupported.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from pre_commit import lang_base
+
+ENVIRONMENT_DIR = None
+get_default_version = lang_base.basic_get_default_version
+health_check = lang_base.basic_health_check
+install_environment = lang_base.no_install
+in_env = lang_base.no_env
+run_hook = lang_base.basic_run_hook

pre_commit/languages/unsupported_script.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from pre_commit import lang_base
+from pre_commit.prefix import Prefix
+
+ENVIRONMENT_DIR = None
+get_default_version = lang_base.basic_get_default_version
+health_check = lang_base.basic_health_check
+install_environment = lang_base.no_install
+in_env = lang_base.no_env
+
+
+def run_hook(
+        prefix: Prefix,
+        entry: str,
+        args: Sequence[str],
+        file_args: Sequence[str],
+        *,
+        is_local: bool,
+        require_serial: bool,
+        color: bool,
+) -> tuple[int, bytes]:
+    cmd = lang_base.hook_cmd(entry, args)
+    cmd = (prefix.path(cmd[0]), *cmd[1:])
+    return lang_base.run_xargs(
+        cmd,
+        file_args,
+        require_serial=require_serial,
+        color=color,
+    )

pre_commit/logging_handler.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+from collections.abc import Generator
+
+from pre_commit import color
+from pre_commit import output
+
+logger = logging.getLogger('pre_commit')
+
+LOG_LEVEL_COLORS = {
+    'DEBUG': '',
+    'INFO': '',
+    'WARNING': color.YELLOW,
+    'ERROR': color.RED,
+}
+
+
+class LoggingHandler(logging.Handler):
+    def __init__(self, use_color: bool) -> None:
+        super().__init__()
+        self.use_color = use_color
+
+    def emit(self, record: logging.LogRecord) -> None:
+        level_msg = color.format_color(
+            f'[{record.levelname}]',
+            LOG_LEVEL_COLORS[record.levelname],
+            self.use_color,
+        )
+        output.write_line(f'{level_msg} {record.getMessage()}')
+
+
+@contextlib.contextmanager
+def logging_handler(use_color: bool) -> Generator[None]:
+    handler = LoggingHandler(use_color)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+    try:
+        yield
+    finally:
+        logger.removeHandler(handler)