implab/gradle-common Commit - r37:3be316021669

refactor: replace configureAssembly with configureTask

cin -

r37:3be316021669 default

parent child

Context file:

r37:3be316021669

Collapse all files

common/src/main/java/org/implab/gradle/common/sources/ArtifactAssembly.java +8 -42

		@@ -1,53 +1,19
1	1	package org.implab.gradle.common.sources;
2	2
3	3	import org.eclipse.jdt.annotation.NonNullByDefault;
4		import org.gradle.api.~~Named~~;
	4	import org.gradle.api.Task;
5	5	import org.gradle.api.file.ConfigurableFileCollection;
6	6	import org.gradle.api.file.Directory;
7		import org.gradle.api.file.FileCollection;
8	7	import org.gradle.api.provider.Provider;
9		import org.gradle.api.tasks.Copy;
10	8	import org.gradle.api.tasks.TaskProvider;
11	9
12	10	@NonNullByDefault
13		public final ~~class~~ ArtifactAssembly ~~implements~~ ~~Named~~ {
14		~~private~~ ~~final~~ String name;
15		private final ConfigurableFileCollection sources;
16		private final ConfigurableFileCollection output;
17		private final Provider<Directory> outputDirectory;
18		private final TaskProvider<Copy> task;
19
20		ArtifactAssembly(
21		String name,
22		ConfigurableFileCollection sources,
23		Provider<Directory> outputDirectory,
24		TaskProvider<Copy> task,
25		ConfigurableFileCollection output) {
26		this.name = name;
27		this.sources = sources;
28		this.outputDirectory = outputDirectory;
29		this.task = task;
30		this.output = output;
31		}
	11	public final record ArtifactAssembly(
	12	String name,
	13	Provider<Directory> outputDirectory,
	14	TaskProvider<? extends Task> task,
	15	ConfigurableFileCollection output
	16	) {
32	17
33		@Override
34		public String getName() {
35		return name;
36		}
37
38		public ConfigurableFileCollection getSources() {
39		return sources;
40		}
	18	};
41	19
42		public FileCollection getOutput() {
43		return output;
44		}
45
46		public Provider<Directory> getOutputDirectory() {
47		return outputDirectory;
48		}
49
50		public TaskProvider<Copy> getTask() {
51		return task;
52		}
53		}

common/src/main/java/org/implab/gradle/common/sources/ArtifactAssemblyRegistry.java +16 -4

              import java.util.LinkedHashMap;
              import java.util.Map;
              import java.util.Optional;
+             import java.util.function.Function;
              import org.eclipse.jdt.annotation.NonNullByDefault;
              import org.gradle.api.Action;
              import org.gradle.api.InvalidUserDataException;
+             import org.gradle.api.Task;
              import org.gradle.api.file.ConfigurableFileCollection;
              import org.gradle.api.file.Directory;
              import org.gradle.api.model.ObjectFactory;
              import org.gradle.api.provider.Provider;
              import org.gradle.api.tasks.Copy;
              import org.gradle.api.tasks.TaskContainer;
+             import org.gradle.api.tasks.TaskProvider;
              import org.gradle.language.base.plugins.LifecycleBasePlugin;
              @NonNullByDefault
                          String taskName,
                          Provider<Directory> outputDirectory,
                          Action<? super ConfigurableFileCollection> configureSources) {
-                     if (assemblies.containsKey(name)) {
-                         throw new InvalidUserDataException("Artifact assembly '" + name + "' is already registered");
+                     }
                      var sources = objects.fileCollection();
                      configureSources.execute(sources);
                          copy.from(sources);
                      });
+                     return register(name, task, t -> outputDirectory);
+                 }
+                 public <T extends Task> ArtifactAssembly register(
+                         String name,
+                         TaskProvider<T> task,
+                         Function<? super T, ? extends Provider<Directory>> mapOutputDirectory) {
+                     if (assemblies.containsKey(name)) {
+                         throw new InvalidUserDataException("Artifact assembly '" + name + "' is already registered");
+                     }
+                     var outputDirectory = task.flatMap(t -> mapOutputDirectory.apply(t));
                      var output = objects.fileCollection()
                              .from(outputDirectory)
                              .builtBy(task);
-                     var assembly = new ArtifactAssembly(name, sources, outputDirectory, task, output);
+                     var assembly = new ArtifactAssembly(name, outputDirectory, task, output);
                      assemblies.put(name, assembly);
                      return assembly;
                  }

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

              import java.util.concurrent.Callable;
              import java.util.function.Function;
              import java.util.stream.Collectors;
+             import java.util.stream.Stream;
              import javax.inject.Inject;
                   * files under them.
                   */
                  public void declareOutputs(String name, String... extra) {
-                     declaredOutputs.add(Objects.requireNonNull(name, "declareOutputs: The output name cannot be null"));
-                     for (var x : extra)
-                         declaredOutputs.add(Objects.requireNonNull(x, "declareOutputs: The output name cannot be null"));
+                     Stream.concat(Stream.of(name), Stream.of(extra))
+                             .map(Objects::requireNonNull)
+                             .forEach(declaredOutputs::add);
                  }
                  /**

common/src/main/java/org/implab/gradle/common/sources/OutgoingArtifactSlotPublication.java +6 -9

              import org.eclipse.jdt.annotation.NonNullByDefault;
              import org.gradle.api.Action;
+             import org.gradle.api.Task;
              import org.gradle.api.attributes.AttributeContainer;
              import org.gradle.api.attributes.HasConfigurableAttributes;
              import org.implab.gradle.common.core.lang.Closures;
                      return slot;
                  }
-                 public ArtifactAssembly assembly() {
-                     return assembly;
+                 public void configureTask(Action<? super Task> action) {
+                     assembly.task().configure(action::execute);
                  }
-                 public void configureAssembly(Action<? super ArtifactAssembly> action) {
-                     action.execute(assembly);
+                 }
-                 public void configureAssembly(
-                         @DelegatesTo(value = ArtifactAssembly.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
-                     configureAssembly(Closures.action(action));
+                 public void configureTask(
+                         @DelegatesTo(value = Task.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
+                     configureTask(Closures.action(action));
                  }
                  public void configureArtifactAttributes(Action<? super AttributeContainer> action) {

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsPlugin.java +4 -4

                  }
                  private static void publishArtifact(ConfigurationPublications outgoing, ArtifactAssembly assembly) {
-                     outgoing.artifact(assembly.getOutput().getSingleFile(), published -> {
-                         published.builtBy(assembly.getOutput().getBuildDependencies());
+                     outgoing.artifact(assembly.output().getSingleFile(), published -> {
+                         published.builtBy(assembly.output().getBuildDependencies());
                      });
                  }
                  private static void publishArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
-                     variant.artifact(assembly.getOutput().getSingleFile(), published -> {
-                         published.builtBy(assembly.getOutput().getBuildDependencies());
+                     variant.artifact(assembly.output().getSingleFile(), published -> {
+                         published.builtBy(assembly.output().getBuildDependencies());
                      });
                  }

common/src/test/java/org/implab/gradle/common/sources/VariantsArtifactsPluginFunctionalTest.java +2 -2

                              whenOutgoingVariant { publication ->
                                  publication.slots().each { slotPublication ->
-                                     slotPublication.configureAssembly {
-                                         sources.from(layout.projectDirectory.file("inputs/${slotPublication.slotName()}.txt"))
+                                     slotPublication.configureTask {
+                                         from(layout.projectDirectory.file("inputs/${slotPublication.slotName()}.txt"))
                                      }
                                      slotPublication.configureArtifactAttributes {

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