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	package org.implab.gradle.common.sources;	1	package org.implab.gradle.common.sources;
2		2
3	import org.eclipse.jdt.annotation.NonNullByDefault;	3	import org.eclipse.jdt.annotation.NonNullByDefault;
4	import org.gradle.api.~~Named~~;	4	import org.gradle.api.Task;
5	import org.gradle.api.file.ConfigurableFileCollection;	5	import org.gradle.api.file.ConfigurableFileCollection;
6	import org.gradle.api.file.Directory;	6	import org.gradle.api.file.Directory;
7	import org.gradle.api.file.FileCollection;
8	import org.gradle.api.provider.Provider;	7	import org.gradle.api.provider.Provider;
9	import org.gradle.api.tasks.Copy;
10	import org.gradle.api.tasks.TaskProvider;	8	import org.gradle.api.tasks.TaskProvider;
11		9
12	@NonNullByDefault	10	@NonNullByDefault
13	public final ~~class~~ ArtifactAssembly ~~implements~~ ~~Named~~ {	11	public final record ArtifactAssembly(
14	~~private~~ ~~final~~ String name;	12	String name,
15	private final ConfigurableFileCollection sources;	13	Provider<Directory> outputDirectory,
16	private final ConfigurableFileCollection output;	14	TaskProvider<? extends Task> task,
17	private final Provider<Directory> outputDirectory;	15	ConfigurableFileCollection output
18	private final TaskProvider<Copy> task;	16	) {
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	}
32		17
33	@Override	18	};
34	public String getName() {
35	return name;
36	}
37
38	public ConfigurableFileCollection getSources() {
39	return sources;
40	}
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

             package org.implab.gradle.common.sources;
             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
             public final class ArtifactAssemblyRegistry {
                 private final ObjectFactory objects;
                 private final TaskContainer tasks;
                 private final Map<String, ArtifactAssembly> assemblies = new LinkedHashMap<>();
                 public ArtifactAssemblyRegistry(ObjectFactory objects, TaskContainer tasks) {
                     this.objects = objects;
                     this.tasks = tasks;
                 }
                 public ArtifactAssembly register(
                         String name,
                         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);
                     var task = tasks.register(taskName, Copy.class, copy -> {
                         copy.setGroup(LifecycleBasePlugin.BUILD_GROUP);
                         copy.into(outputDirectory);
                         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;
                 }
                 public Optional<ArtifactAssembly> find(String name) {
                     return Optional.ofNullable(assemblies.get(name));
                 }
                 public ArtifactAssembly require(String name) {
                     return find(name)
                             .orElseThrow(() -> new InvalidUserDataException("Artifact assembly '" + name + "' isn't registered"));
                 }
             }

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

             package org.implab.gradle.common.sources;
             import java.io.File;
             import java.nio.file.Paths;
             import java.util.HashSet;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Set;
             import java.util.concurrent.Callable;
             import java.util.function.Function;
             import java.util.stream.Collectors;
+            import java.util.stream.Stream;
             import javax.inject.Inject;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.Task;
             import org.gradle.api.file.ConfigurableFileCollection;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.FileCollection;
             import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.file.SourceDirectorySet;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.tasks.TaskProvider;
             import org.gradle.util.Configurable;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             /**
              * A configurable source set abstraction with named outputs.
              *
              * <p>
              * Each instance aggregates multiple {@link SourceDirectorySet source sets}
              * under a shared name and exposes typed outputs that must be declared up front.
              * Default locations are {@code src/<name>} for sources and
              * {@code build/<name>} for outputs, both of which can be customized via the
              * exposed {@link DirectoryProperty} setters.
              * </p>
              *
              * <p>
              * Outputs are grouped by names to make task wiring explicit. An output must be
              * declared with {@link #declareOutputs(String, String...)} before files can be
              * registered against it. Attempting to register or retrieve an undeclared
              * output results in
              * {@link InvalidUserDataException}.
              * </p>
              */
             public abstract class GenericSourceSet
                     implements Named, Configurable<GenericSourceSet> {
                 private final String name;
                 private final NamedDomainObjectContainer<SourceDirectorySet> sourceDirectorySets;
                 private final Map<String, ConfigurableFileCollection> outputs;
                 private final FileCollection allOutputs;
                 private final FileCollection allSourceDirectories;
                 private final ObjectFactory objects;
                 private final Set<String> declaredOutputs = new HashSet<>();
                 @Inject
                 public GenericSourceSet(String name, ObjectFactory objects, ProjectLayout layout) {
                     this.name = name;
                     this.objects = objects;
                     sourceDirectorySets = objects.domainObjectContainer(
                             SourceDirectorySet.class,
                             this::createSourceDirectorySet);
                     outputs = new LinkedHashMap<>();
                     allSourceDirectories = objects.fileCollection().from(sourceDirectoriesProvider());
                     allOutputs = objects.fileCollection().from(outputsProvider());
                     getSourceSetDir().convention(layout
                             .getProjectDirectory()
                             .dir(Paths.get("src", name).toString()));
                     getOutputsDir().convention(layout
                             .getBuildDirectory()
                             .dir(name));
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 /**
                  * Base directory for this source set. Defaults to {@code src/<name>} under
                  * the project directory.
                  */
                 public abstract DirectoryProperty getSourceSetDir();
                 /**
                  * Base directory for outputs of this source set. Defaults to
                  * {@code build/<name>}.
                  */
                 public abstract DirectoryProperty getOutputsDir();
                 /**
                  * The container of {@link SourceDirectorySet} instances that belong to this
                  * logical source set.
                  */
                 public NamedDomainObjectContainer<SourceDirectorySet> getSets() {
                     return sourceDirectorySets;
                 }
                 /**
                  * All registered outputs grouped across output names.
                  */
                 public FileCollection getAllOutputs() {
                     return allOutputs;
                 }
                 /**
                  * All source directories from every contained {@link SourceDirectorySet}.
                  */
                 public FileCollection getAllSourceDirectories() {
                     return allSourceDirectories;
                 }
                 /**
                  * Returns the file collection for the specified output name, creating it
                  * if necessary.
                  *
                  * @throws InvalidUserDataException if the output was not declared
                  */
                 public FileCollection output(String name) {
                     return configurableOutput(name);
                 }
                 private ConfigurableFileCollection configurableOutput(String name) {
                     requireDeclaredOutput(name);
                     return outputs.computeIfAbsent(name, key -> objects.fileCollection());
                 }
                 /**
                  * Declares allowed output names. Outputs must be declared before registering
                  * files under them.
                  */
                 public void declareOutputs(String name, String... extra) {
-                    declaredOutputs.add(Objects.requireNonNull(name, "declareOutputs: The output name cannot be null"));
+                    Stream.concat(Stream.of(name), Stream.of(extra))
-                    for (var x : extra)
+                            .map(Objects::requireNonNull)
-                        declaredOutputs.add(Objects.requireNonNull(x, "declareOutputs: The output name cannot be null"));
+                            .forEach(declaredOutputs::add);
                 }
                 /**
                  * Registers files produced elsewhere under the given output.
                  */
                 public void registerOutput(String name, Object... files) {
                     configurableOutput(name).from(files);
                 }
                 /**
                  * Registers output files produced by a task, using a mapper to extract the
                  * output from the task. The task will be added as a build dependency of this
                  * output.
                  */
                 public <T extends Task> void registerOutput(String name, TaskProvider<T> task,
                         Function<? super T, ?> mapper) {
                     configurableOutput(name).from(task.map(mapper::apply))
                             .builtBy(task);
                 }
                 /**
                  * Applies a Groovy closure to this source set, enabling DSL-style
                  * configuration.
                  */
                 @Override
                 public GenericSourceSet configure(Closure configure) {
                     Closures.apply(configure, this);
                     return this;
                 }
                 private SourceDirectorySet createSourceDirectorySet(String name) {
                     return objects.sourceDirectorySet(name, name);
                 }
                 private void requireDeclaredOutput(String outputName) {
                     if (!declaredOutputs.contains(outputName)) {
                         throw new InvalidUserDataException(
                                 "Output '" + outputName + "' is not declared for source set '" + name + "'");
                     }
                 }
                 private Callable<List<? extends FileCollection>> outputsProvider() {
                     return () -> outputs.values().stream().toList();
                 }
                 private Callable<Set<File>> sourceDirectoriesProvider() {
                     return () -> sourceDirectorySets.stream()
                             .flatMap(x -> x.getSrcDirs().stream())
                             .collect(Collectors.toSet());
                 }
             }

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

             package org.implab.gradle.common.sources;
             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;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             @NonNullByDefault
             public final class OutgoingArtifactSlotPublication {
                 private final String slotName;
                 private final boolean primary;
                 private final VariantArtifactSlot slot;
                 private final ArtifactAssembly assembly;
                 private final HasConfigurableAttributes<?> attributesCarrier;
                 OutgoingArtifactSlotPublication(
                         String slotName,
                         boolean primary,
                         VariantArtifactSlot slot,
                         ArtifactAssembly assembly,
                         HasConfigurableAttributes<?> attributesCarrier) {
                     this.slotName = slotName;
                     this.primary = primary;
                     this.slot = slot;
                     this.assembly = assembly;
                     this.attributesCarrier = attributesCarrier;
                 }
                 public String slotName() {
                     return slotName;
                 }
                 public boolean primary() {
                     return primary;
                 }
                 public VariantArtifactSlot slot() {
                     return slot;
                 }
-                public ArtifactAssembly assembly() {
+                public void configureTask(Action<? super Task> action) {
-                    return assembly;
+                    assembly.task().configure(action::execute);
                 }
-                public void configureAssembly(Action<? super ArtifactAssembly> action) {
+                public void configureTask(
-                    action.execute(assembly);
+                        @DelegatesTo(value = Task.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
+                    configureTask(Closures.action(action));
-                public void configureAssembly(
-                        @DelegatesTo(value = ArtifactAssembly.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
-                    configureAssembly(Closures.action(action));
                 }
                 public void configureArtifactAttributes(Action<? super AttributeContainer> action) {
                     attributesCarrier.attributes(action);
                 }
                 public void configureArtifactAttributes(
                         @DelegatesTo(value = AttributeContainer.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     configureArtifactAttributes(Closures.action(action));
                 }
             }

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

             package org.implab.gradle.common.sources;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.ArrayList;
             import java.util.stream.Collectors;
             import java.util.stream.Stream;
             import org.gradle.api.GradleException;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.artifacts.ConfigurationPublications;
             import org.gradle.api.artifacts.ConfigurationVariant;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
             import org.implab.gradle.common.core.lang.Strings;
             public abstract class VariantArtifactsPlugin implements Plugin<Project> {
                 private static final Logger logger = Logging.getLogger(VariantArtifactsPlugin.class);
                 public static final String VARIANT_ARTIFACTS_EXTENSION_NAME = "variantArtifacts";
                 @Override
                 public void apply(Project target) {
                     logger.debug("Registering '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
                     target.getPluginManager().apply(VariantsSourcesPlugin.class);
                     var variants = VariantsPlugin.getVariantsExtension(target);
                     var variantSources = target.getExtensions().getByType(VariantSourcesExtension.class);
                     var variantArtifacts = target.getExtensions()
                             .create(VARIANT_ARTIFACTS_EXTENSION_NAME, VariantArtifactsExtension.class);
                     var variantArtifactsResolver = new VariantArtifactsResolver(target.getObjects());
                     var artifactAssemblies = new ArtifactAssemblyRegistry(target.getObjects(), target.getTasks());
                     // Bind variant artifacts resolution to variant sources registration, so that artifact resolution can be performed
                     variantSources.whenBound(variantArtifactsResolver::recordBinding);
                     variants.whenFinalized(model -> {
                         logger.debug("Finalizing variantArtifacts model on project '{}'", target.getPath());
                         variantArtifacts.finalizeModel(model);
                         materializeOutgoingVariants(target, model, variantArtifacts, variantArtifactsResolver, artifactAssemblies);
                         logger.debug("variantArtifacts model finalized on project '{}'", target.getPath());
                     });
                 }
                 public static VariantArtifactsExtension getVariantArtifactsExtension(Project target) {
                     var extension = target.getExtensions().findByType(VariantArtifactsExtension.class);
                     if (extension == null) {
                         logger.error("variantArtifacts extension '{}' isn't found on project '{}'",
                                 VARIANT_ARTIFACTS_EXTENSION_NAME,
                                 target.getPath());
                         throw new GradleException("variantArtifacts extension isn't found");
                     }
                     logger.debug("Resolved '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
                     return extension;
                 }
                 private static void materializeOutgoingVariants(
                         Project project,
                         BuildVariantsExtension topology,
                         VariantArtifactsExtension variantArtifacts,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies) {
                     variantArtifacts.getVariants().stream()
                             .filter(variantArtifact -> !variantArtifact.getSlots().isEmpty())
                             .forEach(variantArtifact -> materializeOutgoingVariant(
                                     project,
                                     topology.require(variantArtifact.getName()),
                                     variantArtifact,
                                     variantArtifactsResolver,
                                     artifactAssemblies,
                                     variantArtifacts));
                 }
                 private static void materializeOutgoingVariant(
                         Project project,
                         BuildVariant topologyVariant,
                         VariantArtifact variantArtifact,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies,
                         VariantArtifactsExtension variantArtifacts) {
                     var assemblies = variantArtifact.getSlots().stream()
                             .collect(Collectors.toMap(
                                     VariantArtifactSlot::getName,
                                     slot -> registerAssembly(project, variantArtifactsResolver, artifactAssemblies, variantArtifact, slot),
                                     (left, right) -> left,
                                     LinkedHashMap::new));
                     var primarySlot = variantArtifact.requirePrimarySlot();
                     var configuration = createOutgoingConfiguration(project, variantArtifact.getName(), primarySlot.getName());
                     var primaryAssembly = assemblies.get(primarySlot.getName());
                     publishPrimaryArtifact(configuration, primaryAssembly);
                     var primaryPublication = new OutgoingArtifactSlotPublication(
                             primarySlot.getName(),
                             true,
                             primarySlot,
                             primaryAssembly,
                             configuration);
                     var secondarySlots = variantArtifact.getSlots().stream()
                             .filter(slot -> !slot.getName().equals(primarySlot.getName()))
                             .map(slot -> new SecondarySlot(slot, assemblies.get(slot.getName())))
                             .toList();
                     var secondaryPublications = new ArrayList<OutgoingArtifactSlotPublication>(secondarySlots.size());
                     secondarySlots.forEach(secondarySlot -> {
                         var secondaryVariant = configuration.getOutgoing().getVariants().create(secondarySlot.slot().getName());
                         publishSecondaryArtifact(secondaryVariant, secondarySlot.assembly());
                         secondaryPublications.add(new OutgoingArtifactSlotPublication(
                                 secondarySlot.slot().getName(),
                                 false,
                                 secondarySlot.slot(),
                                 secondarySlot.assembly(),
                                 secondaryVariant));
                     });
                     var slotPublications = Stream.concat(
                             Stream.of(primaryPublication),
                             secondaryPublications.stream())
                             .toList();
                     variantArtifacts.notifyOutgoingVariant(new OutgoingVariantPublication(
                             variantArtifact.getName(),
                             topologyVariant,
                             variantArtifact,
                             configuration,
                             primaryPublication,
                             slotPublications));
                 }
                 private static ArtifactAssembly registerAssembly(
                         Project project,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies,
                         VariantArtifact variantArtifact,
                         VariantArtifactSlot slot) {
                     return artifactAssemblies.register(
                             variantArtifact.getName() + Strings.capitalize(slot.getName()),
                             "process" + Strings.capitalize(variantArtifact.getName()) + Strings.capitalize(slot.getName()),
                             project.getLayout().getBuildDirectory()
                                     .dir("variant-artifacts/" + variantArtifact.getName() + "/" + slot.getName()),
                             files -> files.from(variantArtifactsResolver.files(variantArtifact.getName(), slot)));
                 }
                 private static Configuration createOutgoingConfiguration(
                         Project project,
                         String variantName,
                         String primarySlotName) {
                     var configName = variantName + "Elements";
                     return project.getConfigurations().consumable(configName, config -> {
                         config.setVisible(true);
                         config.setDescription("Consumable assembled artifacts for variant '" + variantName
                                 + "' with primary slot '" + primarySlotName + "'");
                     }).get();
                 }
                 private static void publishPrimaryArtifact(Configuration configuration, ArtifactAssembly assembly) {
                     publishArtifact(configuration.getOutgoing(), assembly);
                 }
                 private static void publishSecondaryArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
                     publishArtifact(variant, assembly);
                 }
                 private static void publishArtifact(ConfigurationPublications outgoing, ArtifactAssembly assembly) {
-                    outgoing.artifact(assembly.getOutput().getSingleFile(), published -> {
+                    outgoing.artifact(assembly.output().getSingleFile(), published -> {
-                        published.builtBy(assembly.getOutput().getBuildDependencies());
+                        published.builtBy(assembly.output().getBuildDependencies());
                     });
                 }
                 private static void publishArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
-                    variant.artifact(assembly.getOutput().getSingleFile(), published -> {
+                    variant.artifact(assembly.output().getSingleFile(), published -> {
-                        published.builtBy(assembly.getOutput().getBuildDependencies());
+                        published.builtBy(assembly.output().getBuildDependencies());
                     });
                 }
                 private record SecondarySlot(VariantArtifactSlot slot, ArtifactAssembly assembly) {
                 }
             }

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

             package org.implab.gradle.common.sources;
             import static org.junit.jupiter.api.Assertions.assertNotNull;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.io.File;
             import java.io.IOException;
             import java.nio.file.Files;
             import java.nio.file.Path;
             import java.util.List;
             import java.util.stream.Collectors;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.GradleRunner;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.gradle.testkit.runner.UnexpectedBuildFailure;
             import org.junit.jupiter.api.Test;
             import org.junit.jupiter.api.io.TempDir;
             class VariantsArtifactsPluginFunctionalTest {
                 private static final String SETTINGS_FILE = "settings.gradle";
                 private static final String BUILD_FILE = "build.gradle";
                 private static final String ROOT_NAME = "rootProject.name = 'variants-artifacts-fixture'\n";
                 @TempDir
                 Path testProjectDir;
                 @Test
                 void materializesVariantArtifactsAndInvokesOutgoingHooks() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/amd.js", "console.log('amd')\n");
                     writeFile("inputs/mainJs.txt", "mainJs marker\n");
                     writeFile("inputs/amdJs.txt", "amdJs marker\n");
                     writeFile(BUILD_FILE, """
                         import org.gradle.api.attributes.Attribute
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('mainBase')
                             layer('mainAmd')
                             variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
                             }
                         }
                         variantSources {
                             bind('mainBase') {
                                 configureSourceSet {
                                     declareOutputs('js')
                                 }
                             }
                             bind('mainAmd') {
                                 configureSourceSet {
                                     declareOutputs('js')
                                 }
                             }
                             whenBound { ctx ->
                                 if (ctx.sourceSetName() == 'browserMainBase') {
                                     ctx.configureSourceSet {
                                         registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                     }
                                 }
                                 if (ctx.sourceSetName() == 'browserMainAmd') {
                                     ctx.configureSourceSet {
                                         registerOutput('js', layout.projectDirectory.file('inputs/amd.js'))
                                     }
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 primarySlot('mainJs') {
                                     fromRole('main') {
                                         output('js')
                                     }
                                 }
                                 slot('amdJs') {
                                     fromLayer('mainAmd') {
                                         output('js')
                                     }
                                 }
                             }
                             whenOutgoingVariant { publication ->
                                 publication.slots().each { slotPublication ->
-                                    slotPublication.configureAssembly {
+                                    slotPublication.configureTask {
-                                        sources.from(layout.projectDirectory.file("inputs/${slotPublication.slotName()}.txt"))
+                                        from(layout.projectDirectory.file("inputs/${slotPublication.slotName()}.txt"))
                                     }
                                     slotPublication.configureArtifactAttributes {
                                         attribute(Attribute.of('test.slot', String), slotPublication.slotName())
                                     }
                                 }
                             }
                         }
                         tasks.register('probe') {
                             dependsOn 'processBrowserMainJs', 'processBrowserAmdJs'
                             doLast {
                                 def mainDir = layout.buildDirectory.dir('variant-artifacts/browser/mainJs').get().asFile
                                 def amdDir = layout.buildDirectory.dir('variant-artifacts/browser/amdJs').get().asFile
                                 assert new File(mainDir, 'base.js').exists()
                                 assert new File(mainDir, 'amd.js').exists()
                                 assert new File(mainDir, 'mainJs.txt').exists()
                                 assert !new File(amdDir, 'base.js').exists()
                                 assert new File(amdDir, 'amd.js').exists()
                                 assert new File(amdDir, 'amdJs.txt').exists()
                                 def elements = configurations.getByName('browserElements')
                                 def primaryAttr = elements.attributes.getAttribute(Attribute.of('test.slot', String))
                                 def amdVariant = elements.outgoing.variants.getByName('amdJs')
                                 def amdAttr = amdVariant.attributes.getAttribute(Attribute.of('test.slot', String))
                                 println('primarySlot=' + variantArtifacts.requireVariant('browser').requirePrimarySlotName())
                                 println('primaryAttr=' + primaryAttr)
                                 println('amdAttr=' + amdAttr)
                                 println('configurations=' + configurations.matching { it.name == 'browserElements' }.collect { it.name }.join(','))
                                 println('secondaryVariants=' + elements.outgoing.variants.collect { it.name }.sort().join(','))
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primarySlot=mainJs"));
                     assertTrue(result.getOutput().contains("primaryAttr=mainJs"));
                     assertTrue(result.getOutput().contains("amdAttr=amdJs"));
                     assertTrue(result.getOutput().contains("configurations=browserElements"));
                     assertTrue(result.getOutput().contains("secondaryVariants=amdJs"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('typesPackage') {
                                     fromVariant {
                                         output('types')
                                     }
                                 }
                             }
                         }
                         tasks.register('probe') {
                             doLast {
                                 println('primary=' + variantArtifacts.requireVariant('browser').requirePrimarySlotName())
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primary=typesPackage"));
                 }
                 @Test
                 void materializesDirectSlotInputsWithoutVariantSourceBindings() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile("inputs/bundle.js", "console.log('bundle')\n");
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 primarySlot('bundle') {
                                     from(layout.projectDirectory.file('inputs/bundle.js'))
                                 }
                             }
                         }
                         tasks.register('probe') {
                             dependsOn 'processBrowserBundle'
                             doLast {
                                 def bundleDir = layout.buildDirectory.dir('variant-artifacts/browser/bundle').get().asFile
                                 assert new File(bundleDir, 'bundle.js').exists()
                                 println('primary=' + variantArtifacts.requireVariant('browser').requirePrimarySlotName())
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primary=bundle"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void combinesDirectAndTopologyAwareSlotInputs() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/marker.txt", "marker\n");
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantSources {
                             bind('main') {
                                 configureSourceSet {
                                     declareOutputs('js')
                                 }
                             }
                             whenBound { ctx ->
                                 ctx.configureSourceSet {
                                     registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 primarySlot('bundle') {
                                     fromVariant {
                                         output('js')
                                     }
                                     from(layout.projectDirectory.file('inputs/marker.txt'))
                                 }
                             }
                         }
                         tasks.register('probe') {
                             dependsOn 'processBrowserBundle'
                             doLast {
                                 def bundleDir = layout.buildDirectory.dir('variant-artifacts/browser/bundle').get().asFile
                                 assert new File(bundleDir, 'base.js').exists()
                                 assert new File(bundleDir, 'marker.txt').exists()
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void failsOnUnknownVariantReference() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('mainJs') {
                                     fromVariant {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "Variant artifact 'browser' references unknown variant 'browser'");
                 }
                 @Test
                 void failsOnUnknownRoleReference() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('mainJs') {
                                     fromRole('test') {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "Variant artifact 'browser', slot 'mainJs' references unknown role 'test'");
                 }
                 @Test
                 void failsWhenPrimarySlotIsMissingForMultipleSlots() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('typesPackage') {
                                     fromVariant {
                                         output('types')
                                     }
                                 }
                                 slot('js') {
                                     fromVariant {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "Variant artifact 'browser' must declare primary slot because it has multiple slots");
                 }
                 @Test
                 void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('mainBase')
                             layer('extra')
                             variant('browser') {
                                 role('main') {
                                     layers('mainBase')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('extraJs') {
                                     fromLayer('extra') {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "Variant artifact 'browser', slot 'extraJs' references unknown layer 'extra'");
                 }
                 @Test
                 void failsOnLateMutationAfterFinalize() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         afterEvaluate {
                             variantArtifacts.variant('late') {
                                 slot('js') {
                                     fromVariant {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "variantArtifacts model is finalized and cannot configure variants");
                 }
                 @Test
                 void preservesPrimaryResolutionAndAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile(SETTINGS_FILE, """
                         rootProject.name = 'variants-artifacts-fixture'
                         include 'producer', 'consumer'
                         """);
                     writeFile("producer/inputs/types.d.ts", "export type Foo = string\n");
                     writeFile("producer/inputs/index.js", "export const foo = 'bar'\n");
                     var buildscriptClasspath = pluginClasspath().stream()
                             .map(File::getAbsolutePath)
                             .map(path -> "'" + path.replace("\\", "\\\\") + "'")
                             .collect(Collectors.joining(", "));
                     writeFile(BUILD_FILE, """
                         buildscript {
                             dependencies {
                                 classpath files(%s)
                             }
                         }
                         import org.gradle.api.attributes.Attribute
                         def variantAttr = Attribute.of('test.variant', String)
                         def slotAttr = Attribute.of('test.slot', String)
                         subprojects {
                             apply plugin: 'org.implab.gradle-variants-artifacts'
                         }
                         project(':producer') {
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') {
                                         layers('main')
                                     }
                                 }
                             }
                             variantSources {
                                 bind('main') {
                                     configureSourceSet {
                                         declareOutputs('types', 'js')
                                     }
                                 }
                                 whenBound { ctx ->
                                     ctx.configureSourceSet {
                                         registerOutput('types', layout.projectDirectory.file('inputs/types.d.ts'))
                                         registerOutput('js', layout.projectDirectory.file('inputs/index.js'))
                                     }
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                     slot('js') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                                 whenOutgoingVariant { publication ->
                                     publication.configureConfiguration {
                                         attributes.attribute(variantAttr, publication.variantName())
                                     }
                                     publication.primarySlot().configureArtifactAttributes {
                                         attribute(slotAttr, publication.primarySlot().slotName())
                                     }
                                     publication.requireSlot('js').configureArtifactAttributes {
                                         attribute(slotAttr, 'js')
                                     }
                                 }
                             }
                         }
                         project(':consumer') {
                             configurations {
                                 compileView {
                                     canBeResolved = true
                                     canBeConsumed = false
                                     canBeDeclared = true
                                     attributes {
                                         attribute(variantAttr, 'browser')
                                         attribute(slotAttr, 'typesPackage')
                                     }
                                 }
                             }
                             dependencies {
                                 compileView project(':producer')
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                     def jsFiles = configurations.compileView.incoming.artifactView {
                                         attributes {
                                             attribute(slotAttr, 'js')
                                         }
                                     }.files.files.collect { it.name }.sort().join(',')
                                     println('compileFiles=' + compileFiles)
                                     println('jsFiles=' + jsFiles)
                                 }
                             }
                         }
                         """.formatted(buildscriptClasspath));
                     BuildResult result = runner(":consumer:probe").build();
                     assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
                     assertTrue(result.getOutput().contains("jsFiles=js"));
                 }
                 private GradleRunner runner(String... arguments) {
                     return GradleRunner.create()
                             .withProjectDir(testProjectDir.toFile())
                             .withPluginClasspath(pluginClasspath())
                             .withArguments(arguments)
                             .forwardOutput();
                 }
                 private void assertBuildFails(String buildScript, String expectedError) throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, buildScript);
                     var ex = assertThrows(UnexpectedBuildFailure.class, () -> runner("help").build());
                     var output = ex.getBuildResult().getOutput();
                     assertTrue(output.contains(expectedError), () -> "Expected [" + expectedError + "] in output:\n" + output);
                 }
                 private static List<File> pluginClasspath() {
                     try {
                         var classesDir = Path.of(VariantArtifactsPlugin.class
                                 .getProtectionDomain()
                                 .getCodeSource()
                                 .getLocation()
                                 .toURI());
                         var markerResource = VariantArtifactsPlugin.class.getClassLoader()
                                 .getResource("META-INF/gradle-plugins/org.implab.gradle-variants-artifacts.properties");
                         assertNotNull(markerResource, "Plugin marker resource is missing from test classpath");
                         var markerPath = Path.of(markerResource.toURI());
                         var resourcesDir = markerPath.getParent().getParent().getParent();
                         return List.of(classesDir.toFile(), resourcesDir.toFile());
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to build plugin classpath for test", e);
                     }
                 }
                 private void writeFile(String relativePath, String content) throws IOException {
                     Path path = testProjectDir.resolve(relativePath);
                     Files.createDirectories(path.getParent());
                     Files.writeString(path, content);
                 }
             }

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