implab/gradle-common Commit - r9:99956175cc38

WIP moving from TaskSpec to TaskProvider

cin -

r9:99956175cc38 default

parent child

Context file:

r9:99956175cc38

Collapse all files

common/src/main/java/org/implab/gradle/common/utils/Closures.java created 644 +24 0

@@ -0,0 +1,24
	1	package org.implab.gradle.common.utils;
	2
	3	import groovy.lang.Closure;
	4
	5	import org.eclipse.jdt.annotation.NonNullByDefault;
	6	import org.gradle.api.Action;
	7
	8	@NonNullByDefault
	9	public final class Closures {
	10	private Closures() {
	11	}
	12
	13	public static <T> Action<T> action(Closure<?> closure) {
	14	return arg -> {
	15	closure.setDelegate(arg);
	16	closure.call(arg);
	17	};
	18	}
	19
	20	public static void apply(Closure<?> action, Object target) {
	21	action.setDelegate(target);
	22	action.call(target);
	23	}
	24	}

common/src/main/java/org/implab/gradle/common/ProjectMixin.java +3 -4

             package org.implab.gradle.common;
             import javax.inject.Inject;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.Task;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.file.Directory;
             import org.gradle.api.tasks.TaskContainer;
+            import org.gradle.api.tasks.TaskProvider;
             import org.implab.gradle.common.dsl.TaskGroup;
-            import org.implab.gradle.common.dsl.TaskSpec;
             import org.implab.gradle.common.dsl.TasksMixin;
             import org.implab.gradle.common.utils.ExtraProps;
             /** Project configuration traits */
             public interface ProjectMixin extends TasksMixin {
                 @Inject
                 Project getProject();
                 @Override
-                default <T extends Task> TaskSpec<T> task(String name, Class<T> clazz) {
+                default <T extends Task> TaskProvider<T> task(String name, Class<T> clazz) {
-                    var provider = getProject().getTasks().register(name, clazz);
+                    return getProject().getTasks().register(name, clazz);
-                    return new TaskSpec<>(provider);
                 }
                 /** Creates a new task group */
                 default TaskGroup taskGroup(String name) {
                     return new TaskGroup(name) {
                         @Override
                         protected TaskContainer tasks() {
                             return getProject().getTasks();
                         }
                     };
                 }
                 /** Registers the new configuration */
                 default NamedDomainObjectProvider<Configuration> configuration(String name, Action<? super Configuration> configure) {
                     return getProject().getConfigurations().register(name, configure);
                 }
                 /** Returns the project directory */
                 default Directory projectDirectory() {
                     return getProject().getLayout().getProjectDirectory();
                 }
                 /** Applies and returns the specified plugin, the plugin is applied only once. */
                 default <T extends Plugin<Project>> T plugin(Class<T> clazz) {
                     getProject().getPluginManager().apply(clazz);
                     return getProject().getPlugins().findPlugin(clazz);
                 }
                 /**
                  * @param classes The list of classes to register as extensions
                  */
                 default void exportClasses(Class<?>... classes) {
                     var props = ExtraProps.of(getProject());
                     for (var clazz : classes)
                         props.put(clazz.getSimpleName(), clazz);
                 }
                 /** Creates and register a new project extension.
                  *
                  * @param <T> The type of the extension
                  * @param extensionName The name of the extension in the project
                  * @param clazz The class of the extension
                  * @return the newly created extension
                  */
                 default <T> T extension(String extensionName, Class<T> clazz) {
                     T extension = getProject().getObjects().newInstance(clazz);
                     getProject().getExtensions().add(extensionName, extension);
                     return extension;
                 }
             }

common/src/main/java/org/implab/gradle/common/dsl/TaskGroup.java +3 -2

             package org.implab.gradle.common.dsl;
             import java.util.Objects;
             import org.gradle.api.Task;
             import org.gradle.api.tasks.TaskContainer;
+            import org.gradle.api.tasks.TaskProvider;
             public abstract class TaskGroup implements TasksMixin {
                 private final String groupName;
                 protected abstract TaskContainer tasks();
                 public TaskGroup(String name) {
                     Objects.requireNonNull(name, "The group name is required");
                     this.groupName = name;
                 }
                 @Override
-                public <T extends Task> TaskSpec<T> task(String taskName, Class<T> clazz) {
+                public <T extends Task> TaskProvider<T> task(String taskName, Class<T> clazz) {
                     var provider = tasks().register(taskName, clazz);
                     provider.configure(t -> t.setGroup(groupName));
-                    return new TaskSpec<>(provider);
+                    return provider;
                 }
             }

common/src/main/java/org/implab/gradle/common/dsl/TasksMixin.java +3 -2

             package org.implab.gradle.common.dsl;
             import org.gradle.api.Task;
+            import org.gradle.api.tasks.TaskProvider;
             public interface TasksMixin {
-                default TaskSpec<Task> task(String name) {
+                default TaskProvider<Task> task(String name) {
                     return task(name, Task.class);
                 }
-                <T extends Task> TaskSpec<T> task(String name, Class<T> clazz);
+                <T extends Task> TaskProvider<T> task(String name, Class<T> clazz);
             }

common/src/main/java/org/implab/gradle/common/utils/ObjectsMixin.java +5 0

             package org.implab.gradle.common.utils;
             import java.util.function.Supplier;
             import javax.inject.Inject;
             import org.gradle.api.NamedDomainObjectContainer;
+            import org.gradle.api.NamedDomainObjectFactory;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Provider;
             import org.gradle.api.provider.ProviderFactory;
             import groovy.lang.Closure;
             public interface ObjectsMixin {
                 @Inject
                 ObjectFactory getObjects();
                 @Inject
                 ProviderFactory getProviders();
                 default <T> Provider<T> provider(Supplier<T> supplier) {
                     return getProviders().provider(supplier::get);
                 }
                 default <T> Provider<T> provider(Closure<T> closure) {
                     return getProviders().provider(closure);
                 }
                 default <T> T newInstance(Class<T> clazz) {
                     return getObjects().newInstance(clazz);
                 }
                 default <T> T newInstance(Class<T> clazz, Object... params) {
                     return getObjects().newInstance(clazz, params);
                 }
                 default <T> NamedDomainObjectContainer<T> newContainer(Class<T> clazz) {
                     return getObjects().domainObjectContainer(clazz);
                 }
+                default <T> NamedDomainObjectContainer<T> newContainer(Class<T> clazz, NamedDomainObjectFactory<T> factory) {
+                    return getObjects().domainObjectContainer(clazz, factory);
+                }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages