[Dependencies] Define new RuntimeDependency (#249)

Author: giordano

Project.toml

@@ -1,7 +1,7 @@
 name = "BinaryBuilderBase"
 uuid = "7f725544-6523-48cd-82d1-3fa08ff4056e"
 authors = ["Elliot Saba <[email protected]>"]
-version = "1.11.0"
+version = "1.12.0"
 
 [deps]
 CodecZlib = "944b1d66-785c-5afd-91f1-9de20f533193"

src/Dependencies.jl

@@ -1,6 +1,6 @@
 using UUIDs
 
-export Dependency, BuildDependency, HostBuildDependency,
+export Dependency, RuntimeDependency, BuildDependency, HostBuildDependency,
     is_host_dependency, is_target_dependency, is_build_dependency, is_runtime_dependency,
     filter_platforms
 
@@ -18,11 +18,20 @@ Concrete subtypes of `AbstractDependency` are
 
 * [`Dependency`](@ref): a JLL package that is necessary for to build the package
   and to load the generated JLL package.
+* [`RuntimeDependency`](@ref): a JLL package that is necessary only at runtime.  Its
+  artifact will not be installed in the prefix during the build.
 * [`BuildDependency`](@ref): a JLL package that is necessary only to build the
   package.  This will not be a dependency of the generated JLL package.
 * [`HostBuildDependency`](@ref): similar to `BuildDependency`, but it will
   install the artifact for the host platform, instead of that for the target
   platform.
+
+Subtypes of `AbstractDependency` should define the following traits:
+
+* [`is_host_dependency`](@ref)
+* [`is_target_dependency`](@ref)
+* [`is_build_dependency`](@ref)
+* [`is_runtime_dependency`](@ref)
 """
 abstract type AbstractDependency end
 
@@ -81,7 +90,7 @@ struct Dependency <: AbstractDependency
     platforms::Vector{<:AbstractPlatform}
     function Dependency(pkg::PkgSpec, build_version = nothing; compat::String = "",
                         platforms::Vector{<:AbstractPlatform}=[AnyPlatform()])
-        if length(compat) > 0
+        if !isempty(compat)
             spec = PKG_VERSIONS.semver_spec(compat) # verify compat is valid
             if build_version === nothing
                 # Since we usually want to build against the oldest compatible
@@ -107,6 +116,44 @@ is_host_dependency(::Dependency) = false
 is_build_dependency(::Dependency) = true
 is_runtime_dependency(::Dependency) = true
 
+"""
+    RuntimeDependency(dep::Union{PackageSpec,String}; compat::String, platforms::Vector{<:AbstractPlatform})
+
+Define a binary dependency that is only listed as dependency of the generated JLL package,
+but its artifact is not installed in the prefix during the build.  The `dep` argument can be
+either a string with the name of the JLL package or a `Pkg.PackageSpec`.
+
+The optional keyword argument `compat` can be used to specify a string for use
+in the `Project.toml` of the generated Julia package.
+
+The optional keyword argument `platforms` is a vector of `AbstractPlatform`s which indicates
+for which platforms the dependency should be used.  By default `platforms=[AnyPlatform()]`,
+to mean that the dependency is compatible with all platforms.
+"""
+struct RuntimeDependency <: AbstractDependency
+    pkg::PkgSpec
+    compat::String  # semver string for use in Project.toml of the JLL
+    platforms::Vector{<:AbstractPlatform}
+    function RuntimeDependency(pkg::PkgSpec; compat::String = "",
+                                platforms::Vector{<:AbstractPlatform}=[AnyPlatform()])
+        if !isempty(compat)
+            spec = PKG_VERSIONS.semver_spec(compat) # verify compat is valid
+            if pkg.version != PKG_VERSIONS.VersionSpec("*") && !(pkg.version in spec)
+                throw(ArgumentError("PackageSpec version and compat for $(pkg) are incompatible"))
+            end
+        end
+        return new(pkg, compat, platforms)
+    end
+end
+RuntimeDependency(name::AbstractString; compat::String = "", platforms::Vector{<:AbstractPlatform}=[AnyPlatform()]) =
+    RuntimeDependency(PackageSpec(; name); compat, platforms)
+is_host_dependency(::RuntimeDependency) = false
+is_build_dependency(::RuntimeDependency) = false
+is_runtime_dependency(::RuntimeDependency) = true
+# In some cases we may want to automatically convert a `RuntimeDependency` to a `Dependency`
+Base.convert(::Type{Dependency}, dep::RuntimeDependency) =
+    Dependency(dep.pkg; compat=dep.compat, platforms=dep.platforms)
+
 """
     BuildDependency(dep::Union{PackageSpec,String}; platforms)
 
@@ -250,7 +297,7 @@ version(d::Dependency) = __version(d.pkg.version)
 getcompat(d::AbstractDependency) = ""
 getcompat(d::Dependency) = d.compat
 
-for (type, type_descr) in ((Dependency, "dependency"), (BuildDependency, "builddependency"), (HostBuildDependency, "hostdependency"))
+for (type, type_descr) in ((Dependency, "dependency"), (RuntimeDependency, "runtimedependency"), (BuildDependency, "builddependency"), (HostBuildDependency, "hostdependency"))
     JSON.lower(d::type) = Dict("type" => type_descr,
                                "name" => d.pkg.name,
                                "uuid" => string_or_nothing(d.pkg.uuid),
@@ -266,7 +313,7 @@ end
 # dictionaries.  This function converts the dictionary back to the appropriate
 # AbstractDependency.
 function dependencify(d::Dict)
-    if d["type"] in ("dependency", "builddependency", "hostdependency")
+    if d["type"] in ("dependency", "runtimedependency", "builddependency", "hostdependency")
         uuid = isnothing(d["uuid"]) ? d["uuid"] : UUID(d["uuid"])
         compat = d["compat"]
         version = PKG_VERSIONS.VersionSpec(VersionNumber(d["version-major"], d["version-minor"], d["version-patch"]))
@@ -275,6 +322,8 @@ function dependencify(d::Dict)
         platforms = parse_platform.(d["platforms"])
         if d["type"] == "dependency"
             return Dependency(spec; compat, platforms)
+        elseif d["type"] == "runtimedependency"
+            return RuntimeDependency(spec; compat, platforms)
         elseif d["type"] == "builddependency"
             return BuildDependency(spec; platforms)
         elseif d["type"] == "hostdependency"

test/dependencies.jl

@@ -51,7 +51,22 @@ end
     @test getcompat(dep_compat) == "2, ~$(build_version)"
 
     # if build_version and compat don't match, an error should be thrown
-    @test_throws ArgumentError Dependency(PackageSpec(; name = name), build_version, compat = "2.0")
+    @test_throws ArgumentError Dependency(PackageSpec(; name = name), build_version; compat = "2.0")
+
+    run_dep = RuntimeDependency(PackageSpec(; name))
+    @test RuntimeDependency(name) == run_dep
+    @test !is_host_dependency(run_dep)
+    @test is_target_dependency(run_dep)
+    @test !is_build_dependency(run_dep)
+    @test is_runtime_dependency(run_dep)
+    @test getname(run_dep) == name
+    @test getname(PackageSpec(; name)) == name
+    @test getpkg(run_dep) == PackageSpec(; name)
+    # We should be able to convert a `Vector{RuntimeDependency}` to `Vector{Dependency}`
+    @test Dependency[RuntimeDependency(name; compat="~1.8", platforms=[Platform("aarch64", "macos"; cxxstring_abi="cxx03")])] ==
+        [Dependency(name; compat="~1.8", platforms=[Platform("aarch64", "macos"; cxxstring_abi="cxx03")])]
+    # If the version in the PackageSpec and the compat don't match, an error should be thrown
+    @test_throws ArgumentError RuntimeDependency(PackageSpec(; name, version=v"1.2.3"); compat = "2.0")
 
     build_name = "Foo_headers_jll"
     build_dep = BuildDependency(PackageSpec(; name = build_name))
@@ -85,6 +100,10 @@ end
         @test jdep == Dict("type" => "dependency", "name" => name, "uuid" => nothing, "compat" => "", "version-major" => 0x0, "version-minor" => 0x0, "version-patch" => 0x0, "platforms" => ["x86_64-apple-darwin", "aarch64-apple-darwin"])
         @test dependencify(jdep) == dep
 
+        jrun_dep = JSON.lower(run_dep)
+        @test jrun_dep == Dict("type" => "runtimedependency", "name" => name, "uuid" => nothing, "compat" => "", "version-major" => 0x0, "version-minor" => 0x0, "version-patch" => 0x0, "platforms" => ["any"])
+        @test dependencify(jrun_dep) == run_dep
+
         jdep_buildver = JSON.lower(dep_buildver)
         @test jdep_buildver == Dict("type" => "dependency", "name" => name, "uuid" => nothing, "compat" => "~1.2", "version-major" => 0x0, "version-minor" => 0x0, "version-patch" => 0x0, "platforms" => ["x86_64-linux-gnu-cxx11"])
         # the build_version is currently not serialized, so the following test fails