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

scons_xo_exts_lib/Builders/elixir.py

@@ -0,0 +1,67 @@
+#!/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
+
+
+def _get_mix_project(source: list):
+    for source_node in source:
+        path = source_node.abspath
+
+        if "mix.exs" in path:
+            return path
+
+    raise RuntimeError("No mix-project in specified sources")
+
+
+def _mix_command(env: Environment, args_string: str, cwd: str) -> int:
+    mix_exe = env.get(key="MIX_EXE", default="mix")
+    mix_flags = env.get(key="MIX_FLAGS", default="")
+
+    cmd = f"{mix_exe} {args_string} {mix_flags}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        cwd=cwd,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def elixir_build_action(target, source, env) -> int:
+    elixir_project = _get_mix_project(source=source)
+    elixir_base_dir = os.path.dirname(elixir_project)
+
+    result = _mix_command(
+        env=env,
+        args_string="escript.build",
+        cwd=elixir_base_dir,
+    )
+
+    return result
+
+
+def generate(env: Environment) -> None:
+    elixir_binary_builder = Builder(action=elixir_build_action)
+
+    env.Append(
+        BUILDERS={
+            "ElixirBinary": elixir_binary_builder,
+        },
+    )
+
+
+def exists(env: Environment):
+    return env.Detect("elixir")

scons_xo_exts_lib/Builders/make.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 make_action(target, source, env):
+    make_targets = " ".join(str(t) for t in target)
+
+    make_exe = env.get("MAKE_EXE", "make")
+    make_flags = env.get("MAKE_FLAGS", "")
+
+    cmd = f"{make_exe} {make_flags} {make_targets}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env):
+    make_binary_builder = Builder(action=make_action)
+
+    env.Append(BUILDERS={"MakeBinary": make_binary_builder})
+
+
+def exists(env):
+    return env.Detect("make")

scons_xo_exts_lib/Builders/meson.py

@@ -0,0 +1,44 @@
+#!/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_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def meson_action(target, source, env):
+    source_dir = NodeMangling.get_first_directory(nodes=source)
+    builddir = NodeMangling.get_first_directory(nodes=target)
+
+    meson_exe = env.get("MESON_EXE", "meson")
+    meson_flags = env.get("MESON_FLAGS", "")
+
+    cmd = f"{meson_exe} setup --reconfigure {meson_flags} {builddir}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        cwd=source_dir,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env):
+    meson_builddir_builder = Builder(action=meson_action)
+
+    env.Append(BUILDERS={"MesonBuilddir": meson_builddir_builder})
+
+
+def exists(env):
+    return env.Detect("meson")

scons_xo_exts_lib/Builders/ninja.py

@@ -0,0 +1,42 @@
+#!/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
+
+from scons_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def ninja_action(target, source, env):
+    source_dir = NodeMangling.get_first_directory(nodes=source)
+
+    ninja_exe = env.get("NINJA_EXE", "ninja")
+    ninja_flags = env.get("NINJA_FLAGS", "")
+
+    cmd = f"{ninja_exe} {ninja_flags} -C ."
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        cwd=source_dir,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env):
+    ninja_binary_builder = Builder(action=ninja_action)
+
+    env.Append(BUILDERS={"NinjaBinary": ninja_binary_builder})
+
+
+def exists(env):
+    return env.Detect("ninja")

scons_xo_exts_lib/Builders/orgmode.py

@@ -0,0 +1,109 @@
+#!/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 shutil import move
+
+from SCons.Script import Builder
+
+from scons_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def _orgmode_extension_to_backend(file_extension: str) -> str:
+    match file_extension:
+        case "info":
+            return "texinfo"
+        case "markdown":
+            return "md"
+        case "pdf":
+            return "latex"
+        case "texi":
+            return "texinfo"
+        case _:
+            return file_extension
+
+
+def _orgmode_extension_to_libraries(file_extension: str) -> list[str]:
+    elisp_libs: list[str] = []
+
+    backend: str = _orgmode_extension_to_backend(file_extension=file_extension)
+
+    if backend != file_extension:
+        elisp_libs.append(f"ox-{backend}")
+
+    return elisp_libs
+
+
+def _orgmode_get_export_flags(target_file: str, source_file: str) -> str:
+    file_extension = os.path.splitext(target_file)[1][1:]
+    backend = _orgmode_extension_to_backend(file_extension=file_extension)
+
+    if file_extension == "texi":
+        fun = "org-texinfo-export-to-texinfo"
+    else:
+        fun = f"org-{backend}-export-to-{file_extension}"
+
+    load_elisp_libs = [
+        "org",
+        "ox-latex",
+    ]
+
+    extension_libs = _orgmode_extension_to_libraries(file_extension=file_extension)
+
+    load_elisp_libs.extend(extension_libs)
+
+    load_flags = " ".join([f"-l {s}" for s in load_elisp_libs])
+    flags = f"{load_flags} {source_file} -f {fun}"
+
+    return flags
+
+
+def orgmode_action(target, source, env):
+    emacs_exe = env.get("EMACS_EXE", "emacs")
+    emacs_exec_flags = env.get("EMACS_EXEC_FLAGS", "-batch -q --no-site-file")
+
+    cwd = NodeMangling.get_first_directory(source)
+
+    inp = NodeMangling.get_first_node(source).abspath
+    out = NodeMangling.get_first_node(target).abspath
+
+    orgmode_flags = _orgmode_get_export_flags(target_file=out, source_file=inp)
+    flags = f"{emacs_exec_flags} {orgmode_flags}"
+
+    cmd = f"{emacs_exe} {flags}"
+
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+        cwd=cwd,
+    )
+
+    # When the target basename is different than export basename we have to do
+    # a file move.
+    if not os.path.exists(out):
+        out_extension = os.path.splitext(out)[1]
+        inp_basename = os.path.splitext(inp)[0]
+
+        move(f"{inp_basename}{out_extension}", out)
+
+    return result.returncode
+
+
+def generate(env):
+    orgmode_file_builder = Builder(action=orgmode_action)
+
+    env.Append(BUILDERS={"OrgmodeFile": orgmode_file_builder})
+
+
+def exists(env):
+    return env.Detect("orgmode")

scons_xo_exts_lib/Builders/pandoc.py

@@ -0,0 +1,42 @@
+#!/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
+
+from scons_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def pandoc_action(target, source, env):
+    pandoc_exe = env.get("PANDOC_EXE", "pandoc")
+    pandoc_flags = env.get("PANDOC_FLAGS", "")
+
+    inp = NodeMangling.get_first_node(source).abspath
+    out = NodeMangling.get_first_node(target).abspath
+
+    cmd = f"{pandoc_exe} {pandoc_flags} -o {out} {inp}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env):
+    pandoc_file_builder = Builder(action=pandoc_action)
+
+    env.Append(BUILDERS={"PandocFile": pandoc_file_builder})
+
+
+def exists(env):
+    return env.Detect("pandoc")

scons_xo_exts_lib/Builders/racket.py

@@ -0,0 +1,123 @@
+#!/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 _racket_get_plt_user_home(env: Environment) -> str:
+    try:
+        return env["PLTUSERHOME"]
+    except Exception:
+        raise RuntimeError("PLTUSERHOME is unset, please set it in SCons")
+
+
+def _racket_get_raco_exe(env: Environment) -> str:
+    racket_exe: str = env.get(key="RACKET_EXE", default="racket")
+    raco_exe: str = f"{racket_exe} -l raco --"
+
+    return raco_exe
+
+
+def _racket_raco(env: Environment, source_node, args: str) -> None:
+    plt_user_home: str = _racket_get_plt_user_home(env=env)
+    raco: str = _racket_get_raco_exe(env=env)
+
+    extra_variables = {
+        "PLTUSERHOME": plt_user_home,
+    }
+
+    subprocess_env = env.Clone()["ENV"]
+    subprocess_env.update(extra_variables)
+
+    directory: str = NodeMangling.get_first_directory(source_node)
+    cmd = f"{raco} {args}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        cwd=directory,
+        shell=True,
+    )
+
+    if result.returncode == 0:
+        return
+
+    raise RuntimeError(f"Raco command failed, ran: {cmd}")
+
+
+def _racket_install_package(env: Environment, source: list) -> None:
+    for source_node in source:
+        _racket_raco(
+            env=env,
+            source_node=source_node,
+            args="pkg install --auto --skip-installed --no-docs",
+        )
+
+
+def _racket_setup_package(env: Environment, source: list) -> None:
+    for source_node in source:
+        _racket_raco(
+            env=env,
+            source_node=source_node,
+            args="setup --tidy --avoid-main --no-docs",
+        )
+
+
+def _racket_create_exe(env: Environment, target, source) -> None:
+    for target_node, source_node in zip(target, source):
+        out: str = target_node.abspath
+        inp: str = source_node.abspath
+
+        _racket_raco(
+            env=env,
+            source_node=source_node,
+            args=f"exe -v --orig-exe -o {out} {inp}",
+        )
+
+
+def racket_library_action(target, source, env) -> int:
+    try:
+        _racket_install_package(env=env, source=source)
+    except RuntimeError:
+        return 1
+
+    return 0
+
+
+def racket_binary_action(target, source, env) -> int:
+    try:
+        _racket_install_package(env=env, source=source)
+        _racket_setup_package(env=env, source=source)
+        _racket_create_exe(env=env, target=target, source=source)
+    except RuntimeError:
+        return 1
+
+    return 0
+
+
+def generate(env: Environment) -> None:
+    racket_binary_builder = Builder(action=racket_binary_action)
+    racket_library_builder = Builder(action=racket_library_action)
+
+    env.Append(
+        BUILDERS={
+            "RacketBinary": racket_binary_builder,
+            "RacketLibrary": racket_library_builder,
+        }
+    )
+
+
+def exists(env: Environment):
+    return env.Detect(progs="racket")

scons_xo_exts_lib/Builders/tar_image.py

@@ -0,0 +1,40 @@
+#!/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
+
+from scons_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def tar_image_action(target, source, env):
+    target_tar = NodeMangling.get_first_node(target)
+    directory = NodeMangling.get_first_directory(source)
+
+    cmd = f"tar --auto-compress --create --file {target_tar.abspath} ."
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+        cwd=directory,
+    )
+
+    return result.returncode
+
+
+def generate(env) -> None:
+    tar_image_builder = Builder(action=tar_image_action)
+
+    env.Append(BUILDERS={"TarImage": tar_image_builder})
+
+
+def exists(env):
+    return env.Detect("tar_image")

scons_xo_exts_lib/Find.py

@@ -0,0 +1,32 @@
+#!/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 typing import List
+
+
+def find_files(path: str) -> List[str]:
+    if not os.path.exists(path):
+        return []
+
+    abs_path = os.path.abspath(path)
+    files = os.listdir(abs_path)
+
+    return list(map(lambda f: os.path.join(abs_path, f), files))
+
+
+def find_last_directory(path: str) -> str:
+    files = find_files(path)
+
+    dirs = (d for d in files if os.path.isdir(d))
+    dirs = sorted(dirs, reverse=True)
+
+    if not dirs:
+        raise RuntimeError("No files found and so also no latest directory")
+
+    return dirs[0]

scons_xo_exts_lib/GenericExtensions.py

@@ -0,0 +1,38 @@
+#!/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 shutil import rmtree
+
+from SCons.Script import Environment
+
+
+def execute_command(env: Environment, command: str) -> None:
+    result = env.Execute(command)
+
+    if result:
+        raise RuntimeError(f"Command failed, given: {command}")
+
+
+def remove(path: str, *args, **kwargs):
+    pwd = os.getcwd()
+
+    rmtree(os.path.join(pwd, path), *args, **kwargs)
+
+
+def find_remove(env: Environment, file_name: str):
+    find_exe = env.get("FIND_EXE", "find")
+
+    rm_exe = env.get("RM_EXE", "rm")
+    rm_flags = env.get("RM_FLAGS", "-f -r")
+    rm_cmd = f"{rm_exe} {rm_flags}"
+
+    execute_command(
+        env,
+        f"{find_exe} . -name '{file_name}' -exec {rm_cmd} {{}} +",
+    )

scons_xo_exts_lib/Read.py

@@ -0,0 +1,53 @@
+#!/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 typing import List
+
+
+def read_lines(file_path: str) -> List[str]:
+    """
+    Return all file lines.
+    """
+
+    lines = []
+
+    with open(file_path) as file:
+        lines = file.readlines()
+
+    return lines
+
+
+def read_line(file_path: str) -> str:
+    """
+    Return 1st file line.
+    """
+
+    lines = read_lines(file_path)
+
+    return lines[0].strip()
+
+
+def read_version(base_path: str) -> str:
+    """
+    Return content of a "VERSION" file found at the "base_path".
+    """
+
+    version_file = os.path.join(base_path, "VERSION")
+
+    return read_line(version_file)
+
+
+def read_python_version(base_path: str) -> str:
+    """
+    Return content of a ".python-version" file found at the "base_path".
+    """
+
+    version_file = os.path.join(base_path, ".python-version")
+
+    return read_line(version_file)

scons_xo_exts_lib/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+
+"""
+Scons extensions library by XGQT.
+"""
+
+__version__ = "1.3.0"
+__description__ = "Scons extensions library by XGQT"

scons_xo_exts_lib-1.3.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: scons-xo-exts-lib
+Version: 1.3.0
+Summary: Scons extensions library by XGQT.
+Author-email: Maciej Barć <xgqt@xgqt.org>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Dist: scons>=4.8.1
+Project-URL: Home, https://gitlab.com/xgqt/xgqt-python-lib-scons-xo-exts/
+
+# SCons XO Exts
+
+SCons extensions
+
+## About
+
+Extensions for SCons, includes Python libraries and builders.
+
+## Repository
+
+Upstream repository is <https://gitlab.com/xgqt/xgqt-python-lib-scons-xo-exts/>.
+
+## Package
+
+Download from PYPI: <https://pypi.org/project/scons-xo-exts-lib/>.
+
+## License
+
+### Code
+
+Code in this project is licensed under the MPL, version 2.0.
+
+    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/.
+