Hello, How to configure lazily a task property (that is not lazy) ? I would like to configure a Copy task

includeEmptyDirs

property using a custom project extension. The extension will have a

Property<Boolean>

. How to apply my extension property lazily ? As a workaround I was thinking to use

doFirst{}

during my task configuration :

doFirst {
    includeEmptyDirs = extension.includeEmptyDirs.get()    
}

You don't have many options besides

afterEvaluate {}

(and do

finalizeValue()

there to make sure the extension cannot be reconfigured afterwards)

doFirst {}

should also work I think; but make sure you also declare your extension property as task input (

inputs.property("my-plugin-includeEmptyDirs", extension.includeEmptyDirs)

) for proper up-to-date checks

You should really not change a tasks configuration at execution time. Iirc if you ever hope to use configuration cache it should even result in a hard error. Besides that I'm this case I agree with Thomas that not using a

Copy

task, but a

copy { ... }

call at execution time is the better way, in similar situations I would recommend not to use a

Property

in the extension, but a function the body of which does the configuration change.

Thank you @Thomas Broyer and @Vampire. Why gradle

Property<T>

are not

Observable

? If it was the case I could use it to configure non lazy taks. I would end up using it like this :

open class JavaOptionsExtension @Inject constructor(objectFactory: ObjectFactory) {
    val javaVersion: ObservableProperty<JavaVersion> = objectFactory.observableProperty()
}

the<JavaOptionsExtension>().apply {
    javaVersion.onChange {
        java{
            sourceCompatibility= javaVersion.get()
            targetCompatibility= javaVersion.get()
        }
    }
}

That you have to ask Gradle folks. Probably because you really should not do that but properly wire things together, only requesting them at execution phase. 🤷‍♂️

I opened a feature request but my explanations are not very clear 😅. https://github.com/gradle/gradle/issues/33062

Thinking about it, I guess a problem will be that it is not really determinable when a property changes. Because often you wire a property to another property that is wired to another property that is wired to another property, and the value could even depend on some task being executed first. So you can maybe get notification about the direct value source being set, but probably not reliably about the actual value changing.

Also, ValueSource.

The very begining of some sort of plugin: https://github.com/evantill/observable-property-gradle-plugin

Gradle is moving to make everything a Property in v9 (even using bytecode rewriting at runtime IIUC) so this should not be needed in the long term.

Unfortunately not 😞