scons-xo-exts-lib 1.3.0__py3-none-any.whl

scons_xo_exts_lib/Actions/Uv.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import os
+
+from SCons.Script import Environment
+
+from ..GenericExtensions import execute_command
+
+
+def uv_venv_action(target, source, env):
+    if os.path.exists(".venv"):
+        return
+    else:
+        env.Execute("${UV_EXE} venv")
+
+
+def uv_sync_action(target, source, env):
+    execute_command(env, "${UV_EXE} sync --all-packages")
+
+
+def uv_pip(env, cmd):
+    execute_command(env, "${UV_EXE} pip " + cmd)
+
+
+def uv_pip_freeze_action(target, source, env):
+    output_file = str(target[0])
+
+    uv_pip(env, f"freeze --exclude-editable > {output_file}")
+
+
+def uv_build_pkg_action(target, source, env):
+    if source:
+        flags = " ".join(str(s) for s in source)
+    else:
+        flags = "--all-packages"
+
+    execute_command(env, "${UV_EXE} build " + flags)
+
+
+def uv_pytest_action(target, source, env):
+    pytest_exec_flags = env.get("PYTEST_FLAGS", "--capture=no")
+
+    execute_command(env, f"${{UV_EXE}} run -- pytest {pytest_exec_flags}")

scons_xo_exts_lib/Actions/__init__.py

@@ -0,0 +1 @@
+#!/usr/bin/env python

scons_xo_exts_lib/BuildSupport/Make.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+from typing import List
+
+from SCons.Script import Environment
+
+from .GenericExtensions import execute_command
+
+
+def execute_make(env: Environment, args: List[str]) -> None:
+    make_cmd = "make" + " ".join(args)
+
+    execute_command(env, make_cmd)

scons_xo_exts_lib/BuildSupport/NodeMangling.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import os
+import re
+
+
+def get_first_node(nodes):
+    if isinstance(nodes, list):
+        return nodes[0]
+
+    return nodes
+
+
+def get_first_directory(nodes):
+    node = get_first_node(nodes=nodes)
+    path = node.abspath
+
+    if os.path.isdir(path):
+        return path
+
+    return os.path.dirname(path)
+
+
+def regex_find_node(regex, nodes):
+    for node in nodes:
+        if re.match(pattern=regex, string=str(node.abspath)):
+            return node
+
+    raise RuntimeError("No file was matched using the specified regex")

scons_xo_exts_lib/BuildSupport/__init__.py

@@ -0,0 +1 @@
+#!/usr/bin/env python

scons_xo_exts_lib/Builders/__init__.py

@@ -0,0 +1 @@
+#!/usr/bin/env python

scons_xo_exts_lib/Builders/bazel.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import subprocess
+
+from SCons.Script import Builder
+
+
+def bazel_action(target, source, env):
+    bazel_pkgs = " ".join(str(s) for s in source)
+
+    bazel_exe = env.get("BAZEL_EXE", "bazelisk")
+    bazel_flags = env.get("BAZEL_FLAGS", "")
+
+    cmd = f"{bazel_exe} build {bazel_flags} {bazel_pkgs}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env):
+    bazel_binary_builder = Builder(action=bazel_action)
+
+    env.Append(BUILDERS={"BazelBinary": bazel_binary_builder})
+
+
+def exists(env):
+    return env.Detect("bazel")

scons_xo_exts_lib/Builders/cmake.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import subprocess
+
+from SCons.Script import Builder
+
+
+def cmake_action(target, source, env):
+    cmake_targets = " ".join(str(t) for t in target)
+
+    cmake_exe = env.get("CMAKE_EXE", "cmake")
+    cmake_flags = env.get("CMAKE_FLAGS", "")
+
+    cmd = f"{cmake_exe} {cmake_flags} {cmake_targets}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env):
+    cmake_binary_builder = Builder(action=cmake_action)
+
+    env.Append(BUILDERS={"CmakeBinary": cmake_binary_builder})
+
+
+def exists(env):
+    return env.Detect("cmake")

scons_xo_exts_lib/Builders/dotnet.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import os
+import platform
+import subprocess
+
+from typing import List
+
+from SCons.Script import Builder
+from SCons.Script import Environment
+
+from scons_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def _dotnet_get_dotnet_exe(env: Environment) -> str:
+    dotnet_exe = env.get("DOTNET_EXE")
+
+    if dotnet_exe:
+        return dotnet_exe
+
+    try:
+        return os.path.join(env["DOTNET_ROOT"], "dotnet")
+    except KeyError:
+        return "dotnet"
+
+
+def _dotnet_get_project(source) -> str:
+    regex = ".*\\.(cs|fs|vb|)proj$"
+
+    try:
+        node = NodeMangling.regex_find_node(regex=regex, nodes=source)
+
+        return str(node.abspath)
+    except Exception as exception:
+        raise RuntimeError("No dotnet project file found", exception)
+
+
+def _dotnet_command(env: Environment, source, args: List[str]) -> None:
+    project_file = _dotnet_get_project(source=source)
+    source_directory = os.path.dirname(project_file)
+
+    extra_variables = {
+        "DOTNET_CLI_TELEMETRY_OPTOUT": "1",
+        "DOTNET_NOLOGO": "1",
+        "DOTNET_SKIP_FIRST_TIME_EXPERIENCE": "1",
+        "MSBUILDTERMINALLOGGER": "off",
+    }
+
+    subprocess_env = env.Clone()["ENV"]
+    subprocess_env.update(extra_variables)
+
+    dotnet_exe = _dotnet_get_dotnet_exe(env=env)
+
+    cmd = [dotnet_exe] + args
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        cwd=source_directory,
+        env=subprocess_env,
+    )
+
+    if result.returncode == 0:
+        return
+
+    raise RuntimeError("Dotnet command failed")
+
+
+def _dotnet_detect_rid() -> str:
+    """
+    Returns a dotnet runtime identifier string in the format "{os}-{arch}".
+
+    OS values: linux, linux-musl, windows, osx
+    Arch values: x64, x86, arm, arm64
+    """
+
+    os_name = "unknownos"
+    os_arch = "unknownarch"
+
+    py_os_name = platform.system().lower()
+    py_os_arch = platform.machine().lower()
+
+    match py_os_name:
+        case "linux":
+            if platform.libc_ver()[0] == "glibc":
+                os_name = "linux"
+            else:
+                os_name = "linux-musl"
+        case "darwin":
+            os_name = "osx"
+        case "windows":
+            os_name = "win"
+        case _:
+            os_name = py_os_name
+
+    match py_os_arch:
+        case "x86_64" | "amd64":
+            os_arch = "x64"
+        case "i386" | "i686":
+            os_arch = "x86"
+        case "aarch64":
+            os_arch = "arm64"
+        case _:
+            os_arch = py_os_arch
+
+    return f"{os_name}-{os_arch}"
+
+
+def _dotnet_get_rid(env: Environment) -> str:
+    key = "DOTNET_RUNTIME"
+
+    if key in env:
+        return env[key]
+
+    return _dotnet_detect_rid()
+
+
+def _dotnet_get_configuration(env: Environment) -> str:
+    key = "DOTNET_CONFIGURATION"
+
+    if key in env:
+        return env[key]
+
+    return "Release"
+
+
+def _dotnet_restore(env: Environment, source) -> None:
+    runtime = _dotnet_get_rid(env=env)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "restore",
+            "--force-evaluate",
+            f"--runtime={runtime}",
+        ],
+    )
+
+
+def _dotnet_build(env: Environment, source) -> None:
+    runtime = _dotnet_get_rid(env=env)
+    configuration = _dotnet_get_configuration(env=env)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "build",
+            "--no-restore",
+            f"--runtime={runtime}",
+            f"--configuration={configuration}",
+        ],
+    )
+
+
+def _dotnet_compile(*args, **kwargs) -> None:
+    _dotnet_restore(*args, **kwargs)
+    _dotnet_build(*args, **kwargs)
+
+
+def _dotnet_pack(env: Environment, source, target) -> None:
+    runtime = _dotnet_get_rid(env=env)
+    configuration = _dotnet_get_configuration(env=env)
+
+    target_directory = NodeMangling.get_first_directory(nodes=target)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "pack",
+            "--no-restore",
+            f"--runtime={runtime}",
+            f"--configuration={configuration}",
+            f"--output={target_directory}",
+        ],
+    )
+
+
+def _dotnet_compile_binary(env: Environment, source, target) -> None:
+    runtime = _dotnet_get_rid(env=env)
+    configuration = _dotnet_get_configuration(env=env)
+
+    target_directory = NodeMangling.get_first_directory(nodes=target)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "publish",
+            "--no-restore",
+            "--self-contained",
+            "-p:PublishSingleFile=true",
+            f"--runtime={runtime}",
+            f"--configuration={configuration}",
+            f"--output={target_directory}",
+        ],
+    )
+
+
+def dotnet_package_build_action(target, source, env: Environment) -> int:
+    try:
+        _dotnet_compile(env=env, source=source)
+        _dotnet_pack(env=env, source=source, target=target)
+    except RuntimeError:
+        return 1
+
+    return 0
+
+
+def dotnet_binary_build_action(target, source, env) -> int:
+    try:
+        _dotnet_compile(env=env, source=source)
+        _dotnet_compile_binary(env=env, source=source, target=target)
+    except RuntimeError:
+        return 1
+
+    return 0
+
+
+def generate(env: Environment) -> None:
+    dotnet_binary_builder = Builder(action=dotnet_binary_build_action)
+    dotnet_package_builder = Builder(action=dotnet_package_build_action)
+
+    env.Append(
+        BUILDERS={
+            "DotnetBinary": dotnet_binary_builder,
+            "DotnetPackage": dotnet_package_builder,
+        }
+    )
+
+
+def exists(env: Environment):
+    return env.Detect("dotnet")

scons_xo_exts_lib/Builders/dune.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import os
+import subprocess
+
+from SCons.Script import Builder
+from SCons.Script import Environment
+
+from scons_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def _get_dune_project(source: list):
+    for source_node in source:
+        path = source_node.abspath
+
+        if "dune-project" in path:
+            return path
+
+    raise RuntimeError("No dune-project in specified sources")
+
+
+def _dune_command(env: Environment, args_string: str, cwd: str) -> int:
+    dune_exe = env.get("DUNE_EXE", "dune")
+    dune_flags = env.get("DUNE_FLAGS", "--display=short")
+
+    cmd = f"{dune_exe} {args_string} {dune_flags}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        cwd=cwd,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def _dune_get_install_prefix(target) -> str:
+    """
+    Guess the install prefix for "dune install --prefix=...".
+    """
+
+    separators = ["/bin/", "/lib/"]
+
+    target_node = NodeMangling.get_first_node(target)
+    path = str(target_node)
+
+    try:
+        for separator in separators:
+            if separator in path:
+                substrings = path.split(sep=separator, maxsplit=1)
+                prefix = substrings[0]
+
+                return os.path.abspath(prefix)
+
+        raise RuntimeError("Separator not found in target")
+
+    except Exception:
+        raise RuntimeError(f"Could not guess prefix, given: {path}")
+
+
+def dune_build_action(target, source, env) -> int:
+    dune_project = _get_dune_project(source=source)
+    dune_base_dir = os.path.dirname(dune_project)
+
+    result = _dune_command(
+        env=env,
+        args_string="build @install",
+        cwd=dune_base_dir,
+    )
+
+    return result
+
+
+def dune_image_action(target, source, env) -> int:
+    dune_project = _get_dune_project(source=source)
+    dune_base_dir = os.path.dirname(dune_project)
+
+    install_prefix = _dune_get_install_prefix(target=target)
+
+    result = _dune_command(
+        env=env,
+        args_string=f"install --prefix={install_prefix}",
+        cwd=dune_base_dir,
+    )
+
+    return result
+
+
+def generate(env: Environment) -> None:
+    dune_binary_builder = Builder(action=dune_build_action)
+    dune_image_builder = Builder(action=dune_image_action)
+
+    env.Append(
+        BUILDERS={
+            "DuneBinary": dune_binary_builder,
+            "DuneImage": dune_image_builder,
+        },
+    )
+
+
+def exists(env: Environment):
+    return env.Detect("dune")

scons_xo_exts_lib/Builders/elisp.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import os
+import subprocess
+
+from SCons.Node import FS
+
+from SCons.Script import Builder
+from SCons.Script import Environment
+
+from scons_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def _elisp_construct_load_path(sources: list) -> str:
+    """
+    :param sources: list of files to construct a load path from
+    :returns: Emacs load path command-line options
+    """
+
+    load_path_flags: set[str] = set()
+
+    for source in sources:
+        if isinstance(source, FS.File):
+            dir_name = source.get_dir().relpath
+        else:
+            dir_name = os.path.dirname(str(source))
+
+        # Then check if the directory **really** exists.
+        if dir_name and os.path.exists(dir_name):
+            load_flag = f"-L {dir_name}"
+
+            load_path_flags.add(load_flag)
+
+    return " ".join(load_path_flags)
+
+
+def _elisp_get_emacs_exe(env: Environment) -> str:
+    emacs_exe = env.get("EMACS_EXE")
+    emacs_version = env.get("EMACS_VERSION")
+
+    if not emacs_exe:
+        if emacs_version:
+            return f"emacs-{emacs_version}"
+
+        return "emacs"
+
+    return emacs_exe
+
+
+def _elisp_get_base_command(env: Environment) -> str:
+    exe: str = _elisp_get_emacs_exe(env)
+
+    exec_flags = env.get("EMACS_EXEC_FLAGS", "-batch -q --no-site-file")
+    extra_flags = env.get("EMACS_EXTRA_FLAGS", "")
+
+    return f"{exe} {exec_flags} {extra_flags}"
+
+
+def elisp_autoloads_action(target, source, env) -> int:
+    directory = NodeMangling.get_first_directory(source[0])
+    out = NodeMangling.get_first_node(target).abspath
+
+    base_args = _elisp_get_base_command(env)
+
+    func = f'loaddefs-generate \\"{directory}\\" \\"{out}\\"'
+    flags = f'--eval "({func})"'
+
+    cmd = f"{base_args} {flags}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        cwd=directory,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def elisp_binary_action(target, source, env) -> int:
+    srcs: str = " ".join(str(s) for s in source)
+    load_path: str = _elisp_construct_load_path(sources=source)
+
+    base_args = _elisp_get_base_command(env)
+    comp_flags = env.get("EMACS_COMP_FLAGS", "-L .")
+
+    func = "batch-byte-compile"
+    flags = f"{comp_flags} {load_path} -f {func}"
+
+    cmd = f"{base_args} {flags} {srcs}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env: Environment) -> None:
+    autoloads_builder = Builder(action=elisp_autoloads_action)
+
+    binary_builder = Builder(
+        action=elisp_binary_action,
+        src_suffix=".el",
+        suffix=".elc",
+    )
+
+    env.Append(
+        BUILDERS={
+            "ElispAutoloadsFile": autoloads_builder,
+            "ElispBinary": binary_builder,
+        }
+    )
+
+
+def exists(env: Environment):
+    return env.Detect(progs="elisp")