jolt 0.9.172__py3-none-any.whl → 0.9.435__py3-none-any.whl

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)

jolt/pkgs/googletest.py

@@ -0,0 +1,46 @@
+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 GoogleTest(cmake.CMake):
+    name = "google/test"
+    version = Parameter("1.12.1", help="GoogleTest version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    requires_git = ["git:url=https://github.com/google/googletest.git,rev=release-{version}"]
+    srcdir = "{git[googletest]}"
+    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("gmock")
+        artifact.cxxinfo.libraries.append("gtest")
+
+
+class GTestMain(Task):
+    name = "google/test/main"
+    extends = "google/test"
+
+    def publish(self, artifact, tools):
+        artifact.cxxinfo.libraries.append("gtest_main")
+
+
+class GmockMain(Task):
+    name = "google/mock/main"
+    extends = "google/test"
+
+    def publish(self, artifact, tools):
+        artifact.cxxinfo.libraries.append("gmock_main")
+
+
+TaskRegistry.get().add_task_class(GoogleTest)
+TaskRegistry.get().add_task_class(GTestMain)
+TaskRegistry.get().add_task_class(GmockMain)

jolt/pkgs/gperf.py

@@ -0,0 +1,15 @@
+from jolt import attributes
+from jolt.plugins import autotools, fetch
+from jolt.tasks import TaskRegistry
+
+
+@attributes.common_metadata()
+@attributes.requires("requires_src")
+class GPerf(autotools.Autotools):
+    name = "gperf"
+    version = "3.3"
+    requires_src = ["fetch:alias=src,url=http://ftpmirror.gnu.org/gperf/gperf-{version}.tar.gz"]
+    srcdir = "{fetch[src]}/gperf-{version}"
+
+
+TaskRegistry.get().add_task_class(GPerf)

jolt/pkgs/grpc.py

@@ -0,0 +1,73 @@
+from jolt import attributes, BooleanParameter, Parameter, Task
+from jolt.pkgs import abseil, cares, cmake, nasm, protobuf, re2, ssl, zlib
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_abseil")
+@attributes.requires("requires_cares")
+@attributes.requires("requires_git")
+@attributes.requires("requires_nasm_{system}")
+@attributes.requires("requires_protobuf")
+@attributes.requires("requires_re2")
+@attributes.requires("requires_ssl")
+@attributes.requires("requires_zlib")
+@attributes.system
+@cmake.requires()
+@cmake.use_ninja()
+class Grpc(cmake.CMake):
+    name = "grpc"
+    version = Parameter("1.76.0", help="Grpc version.")
+    shared = BooleanParameter(False, help="Build shared libraries.")
+    generator = "Ninja"
+    requires_abseil = ["abseil:shared={shared}"]
+    requires_cares = ["c-ares:shared={shared}"]
+    requires_git = ["git:url=https://github.com/grpc/grpc.git,path={buildroot}/git_grpc,rev=v{version},submodules=true"]
+    requires_nasm_windows = ["nasm"]
+    requires_protobuf = ["protobuf:shared={shared}"]
+    requires_re2 = ["re2:shared={shared}"]
+    requires_ssl = ["virtual/ssl:shared={shared}"]
+    requires_zlib = ["zlib"]
+    srcdir = "{git[grpc]}"
+    options = [
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+        "CMAKE_CXX_STANDARD=17",
+        "gRPC_ABSL_PROVIDER=package",
+        "gRPC_BUILD_TESTS=OFF",
+        "gRPC_CARES_PROVIDER=package",
+        "gRPC_MSVC_STATIC_RUNTIME=OFF",
+        "gRPC_PROTOBUF_PROVIDER=package",
+        "gRPC_RE2_PROVIDER=package",
+        "gRPC_SSL_PROVIDER=package",
+        "gRPC_ZLIB_PROVIDER=package",
+        "gRPC_USE_SYSTEMD=OFF",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.crt = "Dynamic"
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+
+
+class GrpcC(Task):
+    name = "grpc/c"
+    extends = "grpc"
+
+    def publish(self, artifact, tools):
+        artifact.cxxinfo.crt = "Dynamic"
+        artifact.cxxinfo.libraries.append("grpc")
+
+
+class GrpcCXX(Task):
+    name = "grpc/c++"
+    extends = "grpc"
+
+    def publish(self, artifact, tools):
+        artifact.cxxinfo.crt = "Dynamic"
+        artifact.cxxinfo.libraries.append("grpc++")
+
+
+TaskRegistry.get().add_task_class(Grpc)
+TaskRegistry.get().add_task_class(GrpcC)
+TaskRegistry.get().add_task_class(GrpcCXX)

jolt/pkgs/hdf5.py

@@ -0,0 +1,19 @@
+from jolt import attributes, Parameter
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@cmake.requires()
+class HDF5(cmake.CMake):
+    name = "hdf5"
+    version = Parameter("2.0.0", help="hdf5 version.")
+    requires_git = ["git:url=https://github.com/HDFGroup/hdf5.git,rev={version}"]
+    srcdir = "{git[hdf5]}"
+    options = [
+        "BUILD_SHARED_LIBS=ON",
+        "HDF5_BUILD_EXAMPLES=OFF",
+    ]
+
+
+TaskRegistry.get().add_task_class(HDF5)

jolt/pkgs/help2man.py

@@ -0,0 +1,14 @@
+from jolt import attributes
+from jolt.plugins import autotools, fetch
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_src")
+class Help2Man(autotools.Autotools):
+    name = "help2man"
+    version = "1.47.17"
+    requires_src = ["fetch:alias=src,url=http://ftpmirror.gnu.org/help2man/help2man-{version}.tar.xz"]
+    srcdir = "{fetch[src]}/help2man-{version}"
+
+
+TaskRegistry.get().add_task_class(Help2Man)

jolt/pkgs/inja.py

@@ -0,0 +1,28 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import cmake, nlohmann_json
+from jolt.plugins import git, cmake
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_json")
+@cmake.requires()
+@cmake.use_ninja()
+class Inja(cmake.CMake):
+    name = "inja"
+    version = Parameter("3.5.0", help="Inja version.")
+    tests = BooleanParameter(False, help="Build tests.")
+    requires_git = ["git:url=https://github.com/pantor/inja.git,rev=v{version}"]
+    requires_json = ["nlohmann/json"]
+    srcdir = "{git[inja]}"
+    options = [
+        "BUILD_TESTING={tests[ON,OFF]}",
+        "INJA_USE_EMBEDDED_JSON=OFF",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.incpaths.append("include")
+
+
+TaskRegistry.get().add_task_class(Inja)

jolt/pkgs/jsoncpp.py

@@ -0,0 +1,31 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.pkgs import cmake
+from jolt.plugins import git, cmake, pkgconfig
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.system
+@cmake.requires()
+@cmake.use_ninja()
+class JsonCPP(cmake.CMake):
+    name = "jsoncpp"
+    version = Parameter("1.9.6", help="JsonCPP version.")
+    tests = BooleanParameter(False, help="Build tests.")
+    requires_git = ["git:url=https://github.com/open-source-parsers/jsoncpp.git,rev={version}"]
+    srcdir = "{git[jsoncpp]}"
+    options = [
+        "JSONCPP_WITH_TESTS={tests[ON,OFF]}",
+    ]
+
+    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("jsoncpp_static")
+        else:
+            artifact.cxxinfo.libraries.append("jsoncpp")
+
+
+TaskRegistry.get().add_task_class(JsonCPP)

jolt/pkgs/libarchive.py

@@ -0,0 +1,43 @@
+from jolt import attributes, BooleanParameter, Parameter
+from jolt.tasks import TaskRegistry
+from jolt.plugins import cmake, git
+from jolt.pkgs import bzip2, libexpat, lz4, openssl, xz, zlib, zstd
+
+
+@attributes.requires("requires_bzip2")
+@attributes.requires("requires_expat")
+@attributes.requires("requires_lz4")
+@attributes.requires("requires_openssl")
+@attributes.requires("requires_xz")
+@attributes.requires("requires_zlib")
+@attributes.requires("requires_zstd")
+@attributes.requires("requires_git")
+@cmake.requires()
+@cmake.use_ninja()
+class Libarchive(cmake.CMake):
+    name = "libarchive"
+    version = Parameter("3.8.5", help="libarchive version.")
+    shared = BooleanParameter(False, help="Build shared libraries")
+    requires_bzip2 = ["libbzip2"]
+    requires_git = ["git:url=https://github.com/libarchive/libarchive.git,rev=v{version}"]
+    requires_expat = ["libexpat"]
+    requires_lz4 = ["lz4"]
+    requires_openssl = ["openssl"]
+    requires_xz = ["xz"]
+    requires_zlib = ["zlib"]
+    requires_zstd = ["zstd"]
+    srcdir = "{git[libarchive]}"
+    options = [
+        "CMAKE_POLICY_VERSION_MINIMUM=3.5",
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+        "ENABLE_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("archive")
+
+
+TaskRegistry.get().add_task_class(Libarchive)