I must be misunderstanding something about the combo of

Property#convention

and

Property#map

... (I think I may have a general misunderstanding of convention and atempting to access its value). I have this:

hibernateVersionProperty = project.getObjects().property( String.class );
hibernateVersionProperty.convention( "N/A" );

...

project.getDependencies().add(
        "implementation",
        ormDsl.getHibernateVersionProperty().map( (ormVersion) -> Character.isDigit( ormVersion.charAt( 0 ) )
                ? "org.hibernate.orm:hibernate-core:" + ormVersion
                : null
        )
);

But this continually gives me a complaint when the build does not explicitly set this hibernate-version :

Caused by: org.gradle.api.internal.provider.MissingValueException: Cannot query the value of this provider because it has no value available.

It may be that

add()

is eagerly evaluating that provider. See if

addLater

works.

I don't see addLater. There is addProvider, but that gave me the same

addLater

is on the configuration:

implenentation.dependencies.addLater

…unsure how that relates to addProvider. Yea, have seen the

null

as well

Ahhh... ok, i'll try that

odd. using it:

// lazy initialize dependencies from packaging extension
        packagingScripts.dependencies.addLater(packaging.packagingScript.map { dependencies.create("${it}@zip") })

getByName returns a Configuration though, not a Provider

ah yea it’s

named

that has a provider. ok, that looks like it should work. addLater is documented on DomainObjectCollection as being there since 4.8. Not seeing any kotlin magic in there. This is the full context:

val packagingScripts: Configuration by configurations.creating

        // lazy initialize dependencies from packaging extension
        packagingScripts.dependencies.addLater(packaging.packagingScript.map { dependencies.create("${it}@zip") })

ahh

huh. seeing the same thing:

val prop = objects.property<String>()
prop.convention("N/A")

// this fails with expected error: Supplied String module notation 'N/A' is invalid. Example notations: 'org.gradle:gradle-core:2.2', 'org.mockito:mockito-core:1.9.5:javadoc'.
// dependencies.addProvider("implementation", prop.map { it })

// this fails with: Cannot query the value of this provider because it has no value available.
dependencies.addProvider("implementation", prop.map { null })

Has seen somewhere using

null

to indicate a no-op.

Perhaps. Like I said, I would much prefer to invert tht, but afaik that is not possible

is the goal to not add the dependency if no version (or an invalid version) is specified?

the plugin is published along with the rest of Hibernate. we generally expect (and only really support) the same versions be used for performing the bytecode enhancement and consuming the enhanced classes

yea, definitely not that. this:

implementation micronautExtension.runtime.map { r ->
        switch(r) {
            case 'netty':                                                   (1)
                return "io.netty:netty-buffer:4.1.75.Final"
            case 'tomcat':
                return "org.apache.tomcat.embed:tomcat-embed-core:10.0.18"  (2)
            default:
                return null                                                 (3)
        }
    }

…but it doesn’t seem to work, trying it now.

but no, this is not the one i saw. i'll read through it. thanks!

perhaps. not having any luck with Kotlin DSL, though it should be equivalent in this case:

dependencies {

    // fails with: Cannot query the value of this provider because it has no value available.
    implementation( prop.map {
        null
    })
}

not quite as user friendly, but maybe i'll just drop this for now and focre the user to add the dependency manuallyand keep the versions in sync

no. from what I’ve seen, #value was added more recently to help clarify setting the value vs setting a provider.

but they both have the same overloads

yea. looks like the only diff is that

value

allows chaining. I’ve used extension functions to provide this for clarity: prop.value = something // assignment of a value prop.from(otherProp) // from a provider of some sort

ah, you're right they do define diff return types

couldn’t get a single dependency to be conditionally added via

null

- but you can use

addAllLater

to add a list of deps (empty list for no deps).

configurations.implementation.get().dependencies.addAllLater(prop.map {
    if( it == "N/Addd") { listOf(dependencies.create("io.foo:default-dep:1.2.3")) }
    else { emptyList() }
})

Thanks @Chris Lee I think I am going to drop this though and either : 1. drop this setting and force the user to add the dependency 2. never use null and always use the version of the plugin or an explicitly set version

ah. listOf() is Kotlin syntax. iirc for Groovy it would be a list literal

["a", "b"]

. emptyList() is also Kotlin, would be

[]

iirc.

i use Java

ah. odd that Collections.emptyList() doesn’t work. all it wants is something that is

Iterable

.

so it says 😉

that cast exception looks like perhaps map() isn’t returning a Provider<Iterable> but a Provider<Something> that ends up going into addAllLater.

Ah, yes, ofc. silly mistake. It is returning

Provider<List<?>>

. It does not know because of the emptyList

ah yea. generics….

I'm surprised though

s/b able to do

Collections.<String>emptyList()

for get the right type.

Dependency, but yeah

that’s valid Java syntax

yep

nice

since emptyList is generic

let me check, had some challenges with that before…

🤷🏼 not the first time i'd have seen diffs in groovy v java v kotlin

what does your code calling map() look like?

this is just one of those cases where Gradle is not going to make sense 😄 I'm back to this working now -

project.getDependencies().add(
				"implementation",
				ormDsl.getUseSameVersion().map( (use) -> use
						? "org.hibernate.orm:hibernate-core:" + HibernateVersion.version
						: null
				)
		);

that… works? wasn’t able to get a provider that returns null to work.

yep, it worked fine now

even when it hits the false path and returns null?

i did change the setup a bit

huh. still not getting that work, looks like the Provider layer doesn’t accept null return values.

val prop = objects.property<Boolean>()
prop.convention(false)

// fails with: Cannot query the value of this provider because it has no value available.
dependencies.add("implementation", prop.map { null })

…at least in this repro (Kotlin DSL, Gradle 7.4.2).

yeah, don't know. it works here now

no worries