jolt 0.9.76__py3-none-any.whl → 0.9.429__py3-none-any.whl

jolt/pkgs/autoconf.py

@@ -0,0 +1,41 @@
+from jolt import attributes, Parameter
+from jolt.pkgs import help2man, m4, texinfo
+from jolt.plugins import git, autotools
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_help2man")
+@attributes.requires("requires_m4")
+@attributes.requires("requires_texinfo")
+class Autoconf(autotools.Autotools):
+    name = "autoconf"
+    version = Parameter("2.72", help="Autoconf version.")
+    requires_git = ["fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/autoconf/autoconf-{version}.tar.gz"]
+    requires_help2man = ["help2man"]
+    requires_m4 = ["m4"]
+    requires_texinfo = ["texinfo"]
+    srcdir = "{fetch[src]}/autoconf-{version}"
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        self.unpack(artifact, tools)
+
+    def unpack(self, artifact, tools):
+        with tools.cwd(artifact.path, "bin"):
+            for file in tools.glob("*"):
+                tools.replace_in_file(
+                    file,
+                    artifact.strings.install_prefix,
+                    artifact.final_path)
+
+        with tools.cwd(artifact.path, "share/autoconf"):
+            tools.replace_in_file(
+                "autom4te.cfg",
+                artifact.strings.install_prefix,
+                artifact.final_path)
+
+        artifact.strings.install_prefix = artifact.final_path
+
+
+TaskRegistry.get().add_task_class(Autoconf)

jolt/pkgs/automake.py

@@ -0,0 +1,41 @@
+from jolt import attributes, Parameter, Task
+from jolt.plugins import git, autotools
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_texinfo")
+@autotools.requires(automake=False, libtool=False)
+class Automake(autotools.Autotools):
+    name = "automake"
+    version = Parameter("1.18.1", help="Automake version.")
+    requires_git = ["fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/automake/automake-{version}.tar.xz"]
+    requires_texinfo = ["texinfo"]
+    srcdir = "{fetch[src]}/automake-{version}"
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        self.unpack(artifact, tools)
+
+    def unpack(self, artifact, tools):
+        with tools.cwd(artifact.path, "bin"):
+            for file in tools.glob("*"):
+                tools.replace_in_file(
+                    file,
+                    artifact.strings.install_prefix,
+                    artifact.final_path)
+
+        for file in tools.glob(artifact.path + "/share/automake-*/Automake/Config.pm"):
+            tools.replace_in_file(
+                file,
+                artifact.strings.install_prefix,
+                artifact.final_path)
+
+        with tools.cwd(artifact.path):
+            for file in tools.glob("share/aclocal-*"):
+                artifact.environ.ACLOCAL_PATH.append(file)
+
+        artifact.strings.install_prefix = artifact.final_path
+
+
+TaskRegistry.get().add_task_class(Automake)

jolt/pkgs/b2.py

@@ -0,0 +1,31 @@
+import os
+from jolt import attributes, Parameter
+from jolt.plugins import git
+from jolt.tasks import Task, TaskRegistry
+
+
+@attributes.common_metadata()
+@attributes.requires("requires_git")
+@attributes.system
+class B2(Task):
+    name = "b2"
+    version = Parameter("5.4.2", help="B2 version.")
+    requires_git = ["git:url=https://github.com/bfgroup/b2.git"]
+
+    def run(self, artifact, tools):
+        self.builddir = tools.builddir("build", incremental=True)
+        self.installdir = tools.builddir("install")
+        with tools.cwd("{git[b2]}"):
+            if self.system == "windows":
+                tools.run(".\\bootstrap.bat")
+                tools.run(".\\b2 install --prefix={installdir} --build-dir={builddir} -j{}", tools.cpu_count())
+            else:
+                tools.run("./bootstrap.sh")
+                tools.run("./b2 install --prefix={installdir} --build-dir={builddir} -j{}", tools.cpu_count())
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.installdir):
+            artifact.collect("*", symlinks=True)
+
+
+TaskRegistry.get().add_task_class(B2)

jolt/pkgs/boost.py

@@ -0,0 +1,111 @@
+import os
+from jolt import attributes, Alias, BooleanParameter, Download, IntParameter, Parameter
+from jolt.pkgs import cpython
+from jolt.plugins import git
+from jolt.tasks import Task, TaskRegistry
+from jolt.error import raise_task_error_if
+
+
+@attributes.common_metadata()
+@attributes.requires("requires_git")
+@attributes.requires("requires_python_{python[on,off]}")
+@attributes.system
+class Boost(Task):
+    name = "boost"
+    version = Parameter("1.90.0", help="Boost version.")
+    shared = BooleanParameter(False, help="Build shared libraries")
+    python = BooleanParameter(False, help="Build Boost.Python")
+    bits = IntParameter(64, values=[32, 64], help="Boost address-model")
+    requires_git = ["git:url=https://github.com/boostorg/boost.git,path={buildroot}/git-boost,rev=boost-{version},submodules=true"]
+    requires_python_on = ["cpython"]
+
+    def write_user_config(self, deps, tools):
+        content = ""
+
+        if self.python:
+            py_exe = tools.which("python3")
+            raise_task_error_if(
+                py_exe is None, self,
+                "Boost.Python requested, but no Python interpreter found in PATH.",
+            )
+
+            # Find the dependency where the Python interpreter is located
+            py_dep = None
+            py_prefix = os.path.dirname(os.path.dirname(py_exe))
+            for _, dep in deps.items():
+                if dep.path == py_prefix:
+                    py_dep = dep
+                    break
+
+            raise_task_error_if(
+                py_dep is None, self,
+                "Boost.Python requested, but the Python dependency could not be found.",
+            )
+
+            py_version = str(py_dep.strings.version_major)
+            content += f"using python : {py_version} : {py_prefix}/bin/python{py_version} : {py_prefix}/include/python{py_version} : {py_prefix}/lib ;\n"
+
+        tools.write_file(
+            self.userconfigfile,
+            content,
+        )
+
+    def clean(self, tools):
+        self.builddir = tools.builddir("build", incremental=True)
+        self.installdir = tools.builddir("install")
+        tools.rmtree(self.builddir)
+        tools.rmtree(self.installdir)
+
+    def run(self, deps, tools):
+        self.builddir = tools.builddir("build", incremental=True)
+        self.installdir = tools.builddir("install")
+        self.userconfigfile = tools.expand_path("{builddir}/user-config.jam")
+        self.write_user_config(deps, tools)
+
+        without_libs = []
+        if not self.python:
+            without_libs.append("python")
+
+        bootstrap_cmd = []
+        if without_libs:
+            bootstrap_cmd = ["--without-libraries={}".format(",".join(without_libs))]
+
+        b2_cmd = [
+            "install",
+            "address-model={bits}",
+            "link={shared[shared,static]}",
+            "--prefix={installdir}",
+            "--build-dir={builddir}",
+            "--user-config={userconfigfile}",
+            "-j{}".format(tools.cpu_count()),
+        ]
+
+        with tools.cwd("{git[boost]}"):
+            if self.system == "windows":
+                bootstrap_cmd = [".\\bootstrap.bat", "msvc"] + bootstrap_cmd
+                b2_cmd = [".\\b2"] + b2_cmd
+            else:
+                bootstrap_cmd = ["./bootstrap.sh"] + bootstrap_cmd
+                b2_cmd = ["./b2"] + b2_cmd
+
+            tools.run(" ".join(bootstrap_cmd))
+            tools.run(" ".join(b2_cmd))
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.installdir):
+            artifact.collect("*", symlinks=True)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+
+        with tools.cwd(self.installdir, "lib"):
+            for lib in tools.glob("libboost_*.a"):
+                name, _ = os.path.splitext(os.path.basename(lib))
+                artifact.cxxinfo.libraries.append(name[3:])
+
+            arch = tools.getenv("VSCMD_ARG_TGT_ARCH", "x64")
+            for lib in tools.glob(f"lib*-mt-{arch}-*.lib"):
+                name, _ = os.path.splitext(lib)
+                artifact.cxxinfo.libraries.append(name)
+
+
+TaskRegistry.get().add_task_class(Boost)

jolt/pkgs/boringssl.py

@@ -0,0 +1,32 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import nasm
+from jolt.plugins import cmake, git
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_nasm_{system}")
+@attributes.common_metadata()
+@attributes.system
+@cmake.requires()
+@cmake.use_ninja()
+class BoringSSL(cmake.CMake):
+    name = "boringssl"
+    version = Parameter("0.20251124.0", help="boringssl version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/google/boringssl.git,rev={version}"]
+    requires_nasm_windows = ["nasm"]
+    srcdir = "{git[boringssl]}"
+    options = [
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("ssl")
+        artifact.cxxinfo.libraries.append("crypto")
+
+
+TaskRegistry.get().add_task_class(BoringSSL)

jolt/pkgs/busybox.py

@@ -0,0 +1,39 @@
+from jolt import attributes, influence, Parameter, Task
+from jolt.plugins import git
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+class BusyBox(Task):
+    name = "busybox"
+    defconfig = Parameter(required=False, help="BusyBox defconfig file.")
+    version = Parameter("1.37.0", help="BusyBox version.")
+    requires_git = ["git:url=git://busybox.net/busybox.git,rev={version_tag}"]
+    srcdir = "{git[busybox]}"
+
+    @property
+    def version_tag(self):
+        return str(self.version).replace(".", "_")
+
+    @property
+    def defconfig_arg(self):
+        if self.defconfig:
+            return f"{self.defconfig}_defconfig"
+        return "defconfig"
+
+    def run(self, deps, tools):
+        self.outdir = tools.builddir()
+        self.installdir = tools.builddir("install")
+
+        with tools.cwd(self.srcdir):
+            tools.run("make O={outdir} {defconfig_arg}")
+            tools.run("make O={outdir} -j{}", tools.cpu_count())
+            tools.run("make O={outdir} install DESTDIR={installdir}")
+
+    def publish(self, artifact, tools):
+        artifact.environ.PATH.append("bin")
+        with tools.cwd(self.installdir):
+            artifact.collect("*", symlinks=True)
+
+
+TaskRegistry.get().add_task_class(BusyBox)

jolt/pkgs/bzip2.py

@@ -0,0 +1,43 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.tasks import TaskRegistry
+from jolt.plugins import fetch, ninja
+
+
+@attributes.requires("requires_src")
+@attributes.system
+@ninja.attributes.cflags("cflags_linux_pic_{pic[on,off]}")
+class LibBzip2(ninja.CXXLibrary):
+    name = "libbzip2"
+    binary = "bzip2"
+    version = Parameter("1.0.8", help="bzip2 version.")
+    pic = BooleanParameter(True, help="Build position independent code")
+    shared = BooleanParameter(False, help="Build shared libraries")
+    cstd = 90
+    cflags_darwin_pic_on = ["-fPIC"]
+    cflags_linux_pic_on = ["-fPIC"]
+    incremental = False
+    requires_src = ["fetch:alias=src,url=https://sourceware.org/pub/bzip2/bzip2-{version}.tar.gz"]
+    source_influence = False
+    sources = [
+        "{fetch[src]}/bzip2-{version}/blocksort.c",
+        "{fetch[src]}/bzip2-{version}/bzlib.c",
+        "{fetch[src]}/bzip2-{version}/bzlib.h",
+        "{fetch[src]}/bzip2-{version}/compress.c",
+        "{fetch[src]}/bzip2-{version}/crctable.c",
+        "{fetch[src]}/bzip2-{version}/decompress.c",
+        "{fetch[src]}/bzip2-{version}/huffman.c",
+        "{fetch[src]}/bzip2-{version}/randtable.c",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("bz2")
+        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+
+        with tools.cwd("{fetch[src]}/bzip2-{version}"):
+            artifact.collect("bzlib.h", "include/")
+
+
+TaskRegistry.get().add_task_class(LibBzip2)

jolt/pkgs/cares.py

@@ -0,0 +1,29 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import cmake
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+class CAres(cmake.CMake):
+    name = "c-ares"
+    version = Parameter("1.34.6", help="c-ares version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/c-ares/c-ares.git,rev=v{version}"]
+    srcdir = "{git[c-ares]}"
+    options = [
+        "CARES_SHARED={shared[ON,OFF]}",
+        "CARES_STATIC={shared[OFF,ON]}",
+        "CARES_BUILD_TESTS=OFF",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("cares")
+
+
+TaskRegistry.get().add_task_class(CAres)

jolt/pkgs/catch2.py

@@ -0,0 +1,36 @@
+from jolt import attributes, BooleanParameter, Parameter, Task
+from jolt.pkgs import cmake
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+class Catch2(cmake.CMake):
+    name = "catch2"
+    version = Parameter("3.11.0", help="catch2 version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/catchorg/Catch2.git,rev=v{version}"]
+    srcdir = "{git[Catch2]}"
+    options = [
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("Catch2")
+
+
+class Catch2Main(Task):
+    name = "catch2/main"
+    extends = "catch2"
+
+    def publish(self, artifact, tools):
+        artifact.cxxinfo.libraries.append("Catch2Main")
+
+
+TaskRegistry.get().add_task_class(Catch2)
+TaskRegistry.get().add_task_class(Catch2Main)

jolt/pkgs/cbindgen.py

@@ -0,0 +1,17 @@
+from jolt import attributes
+from jolt.pkgs import rust
+from jolt.plugins import rust
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_rust")
+class CBindgen(rust.Rust):
+    name = "cbindgen"
+    version = "0.29.2"
+    requires_git = ["git:url=https://github.com/mozilla/cbindgen.git,rev=v{version},hash=true"]
+    requires_rust = ["rust"]
+    srcdir = "{git[cbindgen]}"
+
+
+TaskRegistry.get().add_task_class(CBindgen)

jolt/pkgs/cista.py

@@ -0,0 +1,19 @@
+from jolt import attributes, Parameter, Task
+from jolt.plugins import git
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+class Cista(Task):
+    name = "cista"
+    version = Parameter("0.16", help="Cista version.")
+    requires_git = ["git:url=https://github.com/felixguendling/cista.git,rev=v{version}"]
+    srcdir = "{git[cista]}"
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.srcdir):
+            artifact.collect("include/")
+        artifact.cxxinfo.incpaths.append("include")
+
+
+TaskRegistry.get().add_task_class(Cista)

jolt/pkgs/clang.py

@@ -0,0 +1,44 @@
+from jolt import attributes, Parameter, Task
+from jolt.pkgs import llvm
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_llvm")
+class Clang(Task):
+    name = "clang"
+    version = Parameter(llvm.VERSION, help="Clang version.")
+
+    requires_llvm = ["llvm:version={version}"]
+
+    def publish(self, artifact, tools):
+        artifact.environ.LLVM_TOOL_clang = "clang"
+        artifact.environ.LLVM_TOOL_clangpp = "clang++"
+        artifact.environ.AR = "llvm-ar"
+        artifact.environ.CC = "clang"
+        artifact.environ.CXX = "clang++"
+        artifact.environ.LD = "clang++"
+        artifact.environ.NM = "llvm-nm"
+        artifact.environ.OBJCOPY = "llvm-objcopy"
+        artifact.environ.OBJDUMP = "llvm-objdump"
+        artifact.environ.PATH.append("bin")
+        artifact.environ.RANLIB = "llvm-ranlib"
+        artifact.environ.STRIP = "llvm-strip"
+
+
+class ClangFormat(llvm.LLVMFromSrc):
+    name = "clang-format"
+    projects = ["clang", "clang-tools-extra"]
+    targets = []
+    install = ["install-clang-format"]
+
+
+class ClangTidy(llvm.LLVMFromSrc):
+    name = "clang-tidy"
+    projects = ["clang", "clang-tools-extra"]
+    targets = []
+    install = ["install-clang-tidy"]
+
+
+TaskRegistry.get().add_task_class(Clang)
+TaskRegistry.get().add_task_class(ClangFormat)
+TaskRegistry.get().add_task_class(ClangTidy)

jolt/pkgs/cli11.py

@@ -0,0 +1,23 @@
+from jolt import attributes, Parameter
+from jolt.plugins import cmake, fetch
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_src")
+@cmake.requires()
+@cmake.use_ninja()
+class CLI11(cmake.CMake):
+    name = "cli11"
+    version = Parameter("2.6.1", help="CLI11 version.")
+    requires_src = ["fetch:alias=src,url=https://github.com/CLIUtils/CLI11/archive/refs/tags/v{version}.tar.gz"]
+    srcdir = "{fetch[src]}/CLI11-{version}"
+    options = [
+        "CLI11_BUILD_TESTS=OFF",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+
+
+TaskRegistry.get().add_task_class(CLI11)

jolt/pkgs/cmake.py

@@ -0,0 +1,48 @@
+from jolt import attributes, Alias, Download, Parameter
+from jolt.tasks import TaskRegistry
+
+
+@attributes.arch
+@attributes.system
+@attributes.common_metadata()
+class CMakeBin(Download):
+    name = "cmake/bin"
+    version = Parameter("4.2.1", help="CMake version.")
+    url = ["https://github.com/Kitware/CMake/releases/download/v{version}/cmake-{version}-{cmake_system}-{cmake_arch}{cmake_ext}"]
+    collect = [{"files": "*", "cwd": "cmake-{version}-{cmake_system}-{cmake_arch}{cmake_contents}"}]
+
+    @property
+    def cmake_arch(self):
+        if self.system == "darwin":
+            return "universal"
+        if self.arch == "amd64":
+            return "x86_64"
+        return self.arch
+
+    @property
+    def cmake_ext(self):
+        if self.system == "windows":
+            return ".zip"
+        return ".tar.gz"
+
+    @property
+    def cmake_system(self):
+        if self.system == "darwin":
+            return "macos"
+        return self.system
+
+    @property
+    def cmake_contents(self):
+        if self.system == "darwin":
+            return "/CMake.app/Contents"
+        return ""
+
+
+class CMake(Alias):
+    name = "cmake"
+    version = Parameter("4.2.1", help="CMake version.")
+    requires = ["cmake/bin:version={version}"]
+
+
+TaskRegistry.get().add_task_class(CMake)
+TaskRegistry.get().add_task_class(CMakeBin)