How should configuration be passed to Gradle Task from a Gradle extension?

user_304151 0
Viewed 491

I'm creating a Gradle plugin with its corresponding objects for use in the Groovy DSL. I'm confused between the difference and extension and a task and how configuration should be passed between the two along with where the input and out annotations should be put. Here's my task

abstract public class UrlVerify extends DefaultTask {

    @Input
    abstract public Property<String> getUrl();
    
    @TaskAction
    public void verify() {
        System.out.println(getUrl().get().toString());
    }
}

Here's the extension

abstract public class UrlVerifierExtension {

    abstract public Property<String> getUrl();
    abstract public Property<Configuration> getConfiguration();
    abstract public Property<Boolean> getIgnoreFailures();

    public Set<ConflictCategory> getIncludeCategories() {
        return includeCategories;
    }
}

This plugin simply accepts a URL and validates it.

verification {
    url = 'https://www.moooooereee.com/'
    configuration = configurations.runtimeClasspath
    ignoreFailures = false
}

I have the following plugin. I manually needed to pass the URL from the extension to the task and wondered if this is the correct way?

public class UrlVerifierPlugin implements Plugin<Project> {

    @Override
    public void apply(Project project) {
        project.getPluginManager().apply(JavaLibraryPlugin.class);
        UrlVerifierExtension extension = project.getExtensions().create("verification", UrlVerifierExtension.class);
        UrlVerify verifyUrlTask = project.getTasks().create("verifyUrl", UrlVerify.class);
        verifyUrlTask.getUrl().set(extension.getUrl());
    }

}

Along with this, it is also unclear whether the @Input annotation belongs to the properties of the extension or the task?

gradle-plugin build.gradle gradle groovy java
1 Answers

You seem to have followed the examples from the Gradle documentation very precisely. This is the correct way to configure your custom tasks. The exact purpose of extensions is to have user-provided settings which are then consumed by your plugin to configure it and tasks.

Extensions are for the user to provide settings.

Tasks are for executing an action while Gradle is running.

The @Input annotation is used by Gradle to determine if the tasks needs to run. If the tasks has not run before, or if the input value has changed since the previous execution, then the tasks will run again.

Outputs declare some result produced by running the task. An example is a task that compiles Java files. The outputs would the the class files produced from the compilation process. If output files are modified or deleted by something other than the task that created them, then the task that created them is out-of-date, and Gradle will run it again.

Also, a task can declare the outputs of another task as its input. If task A creates some output files, and task B uses the outputs of task A as an input, then task B will be run when task A updates or creates its files.

In your case with the @Input annotation, my guess is that you do not want that in this case, because it tells Gradle that your tasks only needs to run once, then after that, only if the user updates the setting.

user_7138610
Related