jolt 0.9.419__py3-none-any.whl → 0.9.430__py3-none-any.whl

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)

jolt/pkgs/cpython.py

@@ -0,0 +1,196 @@
+from jolt import attributes, Alias, BooleanParameter, Parameter, Task
+from jolt.pkgs import libffi, sqlite, ssl, zlib, zstd, xz
+from jolt.plugins import autotools, git, pkgconfig
+from jolt.tasks import TaskRegistry
+
+
+def _unpack_adjust_scripts(artifact, tools):
+    bindir = "Scripts" if artifact.strings.system == "windows" else "bin"
+
+    with tools.cwd(artifact.path, bindir):
+        # Adjust paths in scripts
+        for script in tools.glob("*"):
+            # Ignore python executables
+            if script.startswith("python"):
+                continue
+            tools.replace_in_file(script, artifact.strings.install_prefix, artifact.final_path)
+
+    artifact.strings.install_prefix = artifact.final_path
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_libffi_{libffi[on,off]}")
+@attributes.requires("requires_sqlite_{sqlite[on,off]}")
+@attributes.requires("requires_ssl_{ssl[on,off]}")
+@attributes.requires("requires_zlib_{zlib[on,off]}")
+@attributes.requires("requires_zstd_{zstd[on,off]}")
+@attributes.requires("requires_xz_{xz[on,off]}")
+@pkgconfig.requires()
+class CPythonPosix(autotools.Autotools):
+    """ Builds and publishes CPython libraries and headers. """
+
+    name = "cpython/posix"
+    version = Parameter("3.14.2", help="CPython version.")
+    libffi = BooleanParameter(True, help="Enable libffi support")
+    sqlite = BooleanParameter(True, help="Enable SQLite support")
+    ssl = BooleanParameter(True, help="Enable SSL support")
+    zlib = BooleanParameter(True, help="Enable zlib support")
+    zstd = BooleanParameter(True, help="Enable zstd support")
+    xz = BooleanParameter(True, help="Enable xz support")
+    requires_git = ["git:url=https://github.com/python/cpython.git,rev=v{version}"]
+    requires_libffi_on = ["libffi"]
+    requires_sqlite_on = ["sqlite"]
+    requires_ssl_on = ["virtual/ssl"]
+    requires_zlib_on = ["virtual/zlib"]
+    requires_zstd_on = ["zstd"]
+    requires_xz_on = ["xz:pic=true"]
+    srcdir = "{git[cpython]}"
+    options = [
+        "--enable-optimizations",
+        "--with-ensurepip=install",
+    ]
+
+    @property
+    def version_major(self):
+        ver = str(self.version).split(".")
+        return f"{ver[0]}.{ver[1]}"
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.strings.version = str(self.version)
+        artifact.strings.version_major = str(self.version_major)
+
+    def unpack(self, artifact, tools):
+        super().unpack(artifact, tools)
+        _unpack_adjust_scripts(artifact, tools)
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_ssl_{ssl[on,off]}")
+@attributes.common_metadata()
+class CPythonWin32(Task):
+    """ Builds and publishes CPython libraries and headers. """
+
+    name = "cpython/win32"
+    version = Parameter("3.14.2", help="CPython version.")
+    ssl = BooleanParameter(True, help="Enable SSL support")
+    requires_git = ["git:url=https://github.com/python/cpython.git,rev=v{version}"]
+    requires_ssl_on = ["virtual/ssl"]
+    srcdir = "{git[cpython]}"
+
+    @property
+    def version_major(self):
+        ver = str(self.version).split(".")
+        return f"{ver[0]}.{ver[1]}"
+
+    @property
+    def version_major_compact(self):
+        ver = str(self.version).split(".")
+        return f"{ver[0]}{ver[1]}"
+
+    def run(self, deps, tools):
+        with tools.cwd(self.srcdir, "PCbuild"):
+            tools.run("build.bat")
+
+    def publish(self, artifact, tools):
+        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+        artifact.strings.version = str(self.version)
+        artifact.strings.version_major = str(self.version_major)
+        with tools.cwd(self.srcdir):
+            artifact.collect("Include", "include")
+            artifact.collect("Lib", "lib")
+        with tools.cwd(self.srcdir, "PCbuild", "amd64"):
+            artifact.collect("python.exe", "bin/python3.exe")
+            artifact.collect("python.exe", "bin/python{version_major}.exe")
+            artifact.collect("*.dll", "bin/")
+            artifact.collect("*.lib", "lib/")
+        with tools.tmpdir() as tmp, tools.cwd(tmp):
+            tools.write_file(
+                "python3.pc",
+                """
+# See: man pkg-config
+prefix=${{pcfiledir}}/../..
+exec_prefix=${{prefix}}/bin
+libdir=${{prefix}}/lib
+includedir=${{prefix}}/include
+
+Name: Python
+Description: Build a C extension for Python
+Version: {version}-{identity}
+Libs: -L${{libdir}} -lpython3
+Cflags: -I${{includedir}}
+""")
+            tools.write_file(
+                "python3-embed.pc",
+                """
+# See: man pkg-config
+prefix=${{pcfiledir}}/../..
+exec_prefix=${{prefix}}/bin
+libdir=${{prefix}}/lib
+includedir=${{prefix}}/include
+
+Name: Python
+Description: Embed Python into an application
+Version: {version}-{identity}
+Libs: -L${{libdir}} -lpython{version_major_compact}
+Cflags: -I${{includedir}}
+""")
+            artifact.collect("*.pc", "lib/pkgconfig/")
+
+    def unpack(self, artifact, tools):
+        super().unpack(artifact, tools)
+        _unpack_adjust_scripts(artifact, tools)
+
+
+@attributes.requires("requires_{system}")
+@attributes.system
+class CPython(Alias):
+    """ Alias for CPython """
+    name = "cpython"
+    version = Parameter("3.14.2", help="CPython version.")
+    requires_darwin = ["cpython/posix:version={version}"]
+    requires_linux = requires_darwin
+    requires_windows = ["cpython/win32:version={version}"]
+
+
+@pkgconfig.to_cxxinfo("python3-embed")
+@attributes.common_metadata()
+@attributes.system
+@pkgconfig.requires()
+class CPythonEmbed(Task):
+    name = "cpython/embed"
+    requires = ["cpython"]
+    selfsustained = True
+
+    def run(self, deps, tools):
+        name = "cpython/win32" if self.system == "windows" else "cpython/posix"
+        self.cpython = deps[name]
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.cpython.path):
+            artifact.collect("*", symlinks=True)
+
+
+@pkgconfig.to_cxxinfo("python3")
+@attributes.common_metadata()
+@attributes.system
+@pkgconfig.requires()
+class CPythonExtend(Task):
+    name = "cpython/extend"
+    requires = ["cpython"]
+    selfsustained = True
+
+    def run(self, deps, tools):
+        name = "cpython/win32" if self.system == "windows" else "cpython/posix"
+        self.cpython = deps[name]
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.cpython.path):
+            artifact.collect("*", symlinks=True)
+
+
+TaskRegistry.get().add_task_class(CPythonPosix)
+TaskRegistry.get().add_task_class(CPythonWin32)
+TaskRegistry.get().add_task_class(CPython)
+TaskRegistry.get().add_task_class(CPythonEmbed)
+TaskRegistry.get().add_task_class(CPythonExtend)

jolt/pkgs/crun.py

@@ -0,0 +1,29 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import libcap
+from jolt.plugins import git, autotools, pkgconfig
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_libcap_{caps[on,off]}")
+@autotools.requires()
+@pkgconfig.requires()
+class CRun(autotools.Autotools):
+    name = "crun"
+    version = Parameter("1.26", help="crun version.")
+    caps = BooleanParameter(False, help="Enable capabilities support.")
+    systemd = BooleanParameter(False, help="Enable systemd support.")
+    requires_git = ["git:url=https://github.com/containers/crun.git,rev={version},submodules=true"]
+    requires_caps_on = ["libcap"]
+    srcdir = "{git[crun]}"
+    options = [
+        # Unable to get ./configure to pick these up from pkg-config
+        "--disable-criu",
+        "--disable-seccomp",
+        "--enable-embedded-yajl",
+        "{caps[,--disable-caps]}",
+        "{systemd[,--disable-systemd]}",
+    ]
+
+
+TaskRegistry.get().add_task_class(CRun)

jolt/pkgs/curl.py

@@ -0,0 +1,38 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import cmake, ssl
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_ssl")
+@attributes.system
+@cmake.requires()
+@cmake.use_ninja()
+class Curl(cmake.CMake):
+    name = "curl"
+    version = Parameter("8.17.0", help="Curl version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/curl/curl.git,rev=curl-{_version_tag},submodules=true"]
+    requires_ssl = ["virtual/ssl"]
+    srcdir = "{git[curl]}"
+    options = [
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+        "CURL_USE_LIBPSL=OFF",
+    ]
+
+    @property
+    def _version_tag(self):
+        return str(self.version).replace('.', '_')
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        if self.system == "windows":
+            artifact.cxxinfo.libraries.append("libcurl_imp")
+        else:
+            artifact.cxxinfo.libraries.append("curl")
+
+
+TaskRegistry.get().add_task_class(Curl)

jolt/pkgs/dbus.py

@@ -0,0 +1,18 @@
+from jolt import attributes, Parameter
+from jolt.pkgs import cmake
+from jolt.plugins import git, cmake, pkgconfig
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+@pkgconfig.requires()
+class DBus(cmake.CMake):
+    name = "dbus"
+    version = Parameter("1.16.2", help="DBus version.")
+    requires_git = ["git:url=https://gitlab.freedesktop.org/dbus/dbus.git,rev=dbus-{version}"]
+    srcdir = "{git[dbus]}"
+
+
+TaskRegistry.get().add_task_class(DBus)

jolt/pkgs/double_conversion.py

@@ -0,0 +1,24 @@
+from jolt import attributes, 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 DoubleConversion(cmake.CMake):
+    name = "double-conversion"
+    version = Parameter("3.4.0", help="double_conversion version.")
+    options = ["BUILD_SHARED_LIBS=ON"]
+    requires_git = ["git:url=https://github.com/google/double-conversion.git,rev=v{version}"]
+    srcdir = "{git[double-conversion]}"
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("double-conversion")
+
+
+TaskRegistry.get().add_task_class(DoubleConversion)

jolt/pkgs/fastfloat.py

@@ -0,0 +1,21 @@
+from jolt import attributes, 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 FastFloat(cmake.CMake):
+    name = "fastfloat"
+    version = Parameter("8.1.0", help="fastfloat version.")
+    requires_git = ["git:url=https://github.com/fastfloat/fast_float.git,rev=v{version}"]
+    srcdir = "{git[fast_float]}"
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+
+
+TaskRegistry.get().add_task_class(FastFloat)

jolt/pkgs/ffmpeg.py

@@ -0,0 +1,28 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import nasm, pkgconfig, xz, xorg
+from jolt.plugins import git, autotools
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_{system}_libx11")
+@attributes.requires("requires_nasm")
+@attributes.requires("requires_xz")
+@attributes.system
+@autotools.requires()
+class FFmpeg(autotools.Autotools):
+    name = "ffmpeg"
+    version = Parameter("8.0.1", help="ffmpeg version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/FFmpeg/FFmpeg.git,rev=n{version}"]
+    requires_linux_libx11 = ["libx11"]
+    requires_nasm = ["nasm"]
+    requires_xz = ["xz"]
+    srcdir = "{git[FFmpeg]}"
+    options = [
+        "--{shared[enable,disable]}-shared",
+        "--{shared[disable,enable]}-static",
+    ]
+
+
+TaskRegistry.get().add_task_class(FFmpeg)

jolt/pkgs/flatbuffers.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 Flatbuffers(cmake.CMake):
+    name = "flatbuffers"
+    version = Parameter("25.9.23", help="Flatbuffers version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/google/flatbuffers.git,rev=v{version}"]
+    srcdir = "{git[flatbuffers]}"
+    options = [
+        "FLATBUFFERS_BUILD_FLATLIB={shared[OFF,ON]}",
+        "FLATBUFFERS_BUILD_SHAREDLIB={shared[ON,OFF]}",
+        "FLATBUFFERS_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("flatbuffers")
+
+
+TaskRegistry.get().add_task_class(Flatbuffers)

jolt/pkgs/fmt.py

@@ -0,0 +1,27 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+class Fmt(cmake.CMake):
+    name = "fmt"
+    version = Parameter("12.1.0", help="Fmt version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/fmtlib/fmt.git,rev={version}"]
+    srcdir = "{git[fmt]}"
+    options = [
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+        "FMT_TEST=OFF",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        artifact.cxxinfo.libraries.append("fmt")
+
+
+TaskRegistry.get().add_task_class(Fmt)

jolt/pkgs/fstree.py

@@ -0,0 +1,20 @@
+from jolt import attributes, Parameter, Task
+from jolt.tasks import TaskRegistry
+
+
+@attributes.system
+class Fstree(Task):
+    name = "fstree"
+    version = Parameter("24.11.128")
+
+    def publish(self, artifact, tools):
+        self.ext = ".exe" if self.system == "windows" else ""
+        with tools.cwd(tools.builddir()):
+            tools.mkdir("jolt/bin")
+            tools.download("https://github.com/srand/fstree/releases/download/{version}/fstree-{system}-x86_64{ext}", "jolt/bin/fstree-{system}-x86_64{ext}")
+            tools.chmod("jolt/bin/fstree-{system}-x86_64{ext}", 0o755)
+            artifact.collect("jolt/bin/fstree-{system}-x86_64{ext}", "bin/fstree{ext}")
+            artifact.environ.PATH.append("bin")
+
+
+TaskRegistry.get().add_task_class(Fstree)

jolt/pkgs/gflags.py

@@ -0,0 +1,18 @@
+from jolt import attributes, 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 GFlags(cmake.CMake):
+    name = "gflags"
+    version = Parameter("2.3.0", help="gflags version.")
+    options = ["BUILD_SHARED_LIBS=ON"]
+    requires_git = ["git:url=https://github.com/gflags/gflags.git,rev=v{version}"]
+    srcdir = "{git[gflags]}"
+
+
+TaskRegistry.get().add_task_class(GFlags)

jolt/pkgs/glib.py

@@ -0,0 +1,18 @@
+from jolt import attributes, Parameter
+from jolt.pkgs import meson, zlib
+from jolt.plugins import git, meson
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_zlib")
+@meson.requires()
+class GLib(meson.Meson):
+    name = "glib"
+    version = Parameter("2.86.3", help="glib version.")
+    requires_git = ["git:url=https://gitlab.gnome.org/GNOME/glib.git,rev={version},submodules=true"]
+    requires_zlib = ["zlib"]
+    srcdir = "{git[glib]}"
+
+
+TaskRegistry.get().add_task_class(GLib)

jolt/pkgs/glog.py

@@ -0,0 +1,25 @@
+from jolt import attributes, Parameter
+from jolt.pkgs import cmake, gflags
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_gflags")
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+class Glog(cmake.CMake):
+    name = "glog"
+    version = Parameter("0.7.1", help="glog version.")
+    options = ["BUILD_SHARED_LIBS=ON"]
+    requires_gflags = ["gflags"]
+    requires_git = ["git:url=https://github.com/google/glog.git,rev=v{version}"]
+    srcdir = "{git[glog]}"
+    options = ["CMAKE_CXX_STANDARD=14"]
+
+    def run(self, deps, tools):
+        self.warning("GLog is deprecated and unmaintained. Consider using ng-log instead.")
+        super().run(deps, tools)
+
+
+TaskRegistry.get().add_task_class(Glog)

jolt/pkgs/glslang.py

@@ -0,0 +1,21 @@
+from jolt import attributes, 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 Glslang(cmake.CMake):
+    name = "glslang"
+    version = Parameter("16.1.0", help="Glslang version.")
+    requires_git = ["git:url=https://github.com/KhronosGroup/glslang.git,rev={version}"]
+
+    def run(self, deps, tools):
+        with tools.cwd("{git[glslang]}"):
+            tools.run("python3 update_glslang_sources.py")
+            super().run(deps, tools)
+
+
+TaskRegistry.get().add_task_class(Glslang)

jolt/pkgs/golang.py

@@ -6,31 +6,36 @@ from jolt.tasks import TaskRegistry
 import platform
 
 
+@jolt_attributes.arch
 @jolt_attributes.system
-@jolt_attributes.attribute("url", "url_{system}")
 class Golang(Download):
     name = "golang"
-    version = Parameter("1.18.3", help="Go version.")
-    url_linux = "https://go.dev/dl/go{version}.linux-{arch}.tar.gz"
-    url_windows = "https://go.dev/dl/go{version}.windows-{arch}.zip"
+    version = Parameter("1.25.5", help="Go version.")
+    url = "https://go.dev/dl/go{version}.{system}-{go_arch}{go_ext}"
 
     @property
-    def arch(self):
-        arch = platform.machine()
-        if arch == "x86_64":
+    def go_arch(self):
+        if self.arch in ["amd64", "x86_64"]:
             return "amd64"
-        if arch in ["i386", "i486", "i586", "i686"]:
+        if self.arch in ["i386", "i486", "i586", "i686"]:
             return "i386"
-        if arch in ["arm", "armv6l", "armv7l"]:
+        if self.arch in ["arm", "armv6l", "armv7l"]:
             return "armv6l"
-        if arch in ["arm64", "armv8l", "aarch64"]:
+        if self.arch in ["arm64", "armv8l", "aarch64"]:
             return "arm64"
         return None
 
+    @property
+    def go_ext(self):
+        if self.system == "windows":
+            return ".zip"
+        return ".tar.gz"
+
     def publish(self, artifact, tools):
         super().publish(artifact, tools)
-        artifact.environ.PATH.append("go/bin")
         artifact.paths.goroot = "go"
+        artifact.environ.GOROOT = str(artifact.paths.goroot)
+        artifact.environ.PATH.append("go/bin")
 
     def unpack(self, artifact, tools):
         artifact.environ.GOROOT = str(artifact.paths.goroot)

jolt/pkgs/googlebenchmark.py

@@ -0,0 +1,18 @@
+from jolt import attributes, Parameter
+from jolt.pkgs import cmake
+from jolt.tasks import TaskRegistry
+from jolt.plugins import git, cmake
+
+
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+class GoogleBenchmark(cmake.CMake):
+    name = "google/benchmark"
+    version = Parameter("1.9.4", help="Benchmark version.")
+    requires_git = ["git:url=https://github.com/google/benchmark.git,rev=v{version},submodules=true"]
+    options = ["BENCHMARK_ENABLE_TESTING=OFF"]
+    srcdir = "{git[benchmark]}"
+
+
+TaskRegistry.get().add_task_class(GoogleBenchmark)