implab/gradle-common Commit - r56:c41a563716ec

variants: refine public API boundary

cin -

r56:c41a563716ec default

parent child

Context file:

r56:c41a563716ec

Collapse all files

variants/src/main/java/org/implab/gradle/variants/internal/IdentityContainerFactory.java created 644 +14 0

@@ -0,0 +1,14
	1	package org.implab.gradle.variants.internal;
	2
	3	import org.gradle.api.Named;
	4	import org.gradle.api.NamedDomainObjectContainer;
	5	import org.gradle.api.model.ObjectFactory;
	6
	7	public final class IdentityContainerFactory {
	8	private IdentityContainerFactory() {
	9	}
	10
	11	public static <T extends Named> NamedDomainObjectContainer<T> create(ObjectFactory objectFactory, Class<T> type) {
	12	return objectFactory.domainObjectContainer(type, name -> objectFactory.named(type, name));
	13	}
	14	}

variants/src/main/java/org/implab/gradle/variants/internal/package-info.java created 644 +7 0

@@ -0,0 +1,7
	1	/**
	2	* Internal implementation utilities of the variants module.
	3	*
	4	* <p>Types in this package are not part of the public API. They may change,
	5	* move, or be removed without compatibility guarantees.
	6	*/
	7	package org.implab.gradle.variants.internal;

variants/src/main/java/org/implab/gradle/variants/sources/internal/package-info.java created 644 +9 0

@@ -0,0 +1,9
	1	/**
	2	* Internal implementation of the variant sources plugin.
	3	*
	4	* <p>Types in this package are not part of the public API. They may change,
	5	* move, or be removed without compatibility guarantees. Build logic should use
	6	* the public contracts from {@link org.implab.gradle.variants.sources}
	7	* instead.
	8	*/
	9	package org.implab.gradle.variants.sources.internal;

variants/build.gradle +4 0

             plugins {
                 id "java-library"
                 id "ivy-publish"
             }
             java {
                 withJavadocJar()
                 withSourcesJar()
                 toolchain {
                     languageVersion = JavaLanguageVersion.of(21)
                 }
             }
             dependencies {
                 compileOnly libs.jdt.annotations
                 api gradleApi(),
                     libs.bundles.jackson
                 implementation project(":common")
                 testImplementation gradleTestKit()
                 testImplementation "org.junit.jupiter:junit-jupiter-api:5.11.4"
                 testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.11.4"
                 testRuntimeOnly "org.junit.platform:junit-platform-launcher:1.11.4"
             }
             task printVersion{
                 doLast {
                     println "project: $project.group:$project.name:$project.version"
                     println "jar: ${->jar.archiveFileName.get()}"
                 }
             }
             test {
                 useJUnitPlatform()
             }
+            javadoc {
+                exclude "**/internal/**"
+            }
             publishing {
                 repositories {
                     ivy {
                         url "${System.properties["user.home"]}/ivy-repo"
                     }
                 }
                 publications {
                     ivy(IvyPublication) {
                         from components.java
                         descriptor.description {
                             text = providers.provider({ description })
                         }
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/VariantArtifactsPlugin.java +1 -1

             package org.implab.gradle.variants;
             import org.gradle.api.Action;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSpec;
             import org.implab.gradle.variants.artifacts.OutgoingVariantsContext;
             import org.implab.gradle.variants.artifacts.VariantArtifactsExtension;
             import org.implab.gradle.variants.artifacts.VariantArtifactsSpec;
             import org.implab.gradle.variants.artifacts.internal.ArtifactAssemblyBinder;
             import org.implab.gradle.variants.artifacts.internal.ArtifactAssemblyHandler;
             import org.implab.gradle.variants.artifacts.internal.ArtifactAssemblyRegistry;
             import org.implab.gradle.variants.artifacts.internal.DefaultOutgoingVariantsContext;
             import org.implab.gradle.variants.artifacts.internal.MaterializationPolicyHandler;
             import org.implab.gradle.variants.artifacts.internal.OutgoingRegistry;
             import org.implab.gradle.variants.artifacts.internal.SingleSlotConvention;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsExtension;
             import org.implab.gradle.variants.sources.VariantSourcesExtension;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSlotSpec;
             public abstract class VariantArtifactsPlugin implements Plugin<Project> {
                 @Override
                 public void apply(Project target) {
                     var extensions = target.getExtensions();
                     var objects = target.getObjects();
                     var providers = target.getProviders();
                     var plugins = target.getPlugins();
                     var configurations = target.getConfigurations();
                     var tasks = target.getTasks();
                     var layout = target.getLayout();
                     // Apply the main VariantsPlugin to ensure the core variant model is available.
                     plugins.apply(VariantsPlugin.class);
                     plugins.apply(VariantSourcesPlugin.class);
                     // Access the VariantsExtension to configure variant sources.
                     var variantsExtension = extensions.getByType(VariantsExtension.class);
                     var sourcesExtension = extensions.getByType(VariantSourcesExtension.class);
                     var deferred = new Deferred<OutgoingVariantsContext>();
                     variantsExtension.whenFinalized(variants -> {
                         var outgoing = new OutgoingRegistry(configurations, objects, variants.getVariants());
                         var assemblies = new ArtifactAssemblyRegistry();
                         // wire artifact assemblies to configuration variants
                         var assembliesBridge = new ArtifactAssemblyBinder(assemblies);
                         var primarySlotConvention = new SingleSlotConvention(providers);
                         var materializationHandler = new MaterializationPolicyHandler(objects);
                         // bind slot assemblies to outgoing variants
                         outgoing.configureEach(assembliesBridge::execute);
                         // apply primary slot convention when outgoing variant has a single slot
                         outgoing.configureEach(primarySlotConvention::execute);
                         // apply materialization policy hooks to outgoing variants
                         outgoing.configureEach(materializationHandler::execute);
-                        sourcesExtension.whenFinalized(sources -> {
+                        sourcesExtension.whenAvailable(sources -> {
                             var assemblyHandler = new ArtifactAssemblyHandler(
                                     objects,
                                     tasks,
                                     assemblies,
                                     sources.getCompileUnits(),
                                     sources.getRoleProjections(),
                                     sources.getSourceSets());
                             assemblyHandler.getAssembliesDirectory().set(layout.getBuildDirectory().dir("variant-assemblies"));
                             deferred.resolve(new DefaultOutgoingVariantsContext(
                                     assemblies,
                                     outgoing,
                                     assemblyHandler,
                                     materializationHandler));
                         });
                     });
                     var variantArtifacts = new VariantArtifactsExtension() {
                         @Override
                         public void variant(String variantName, Action<? super VariantArtifactsSpec> action) {
                             deferred.whenResolved(context -> {
                                 var variant = objects.named(Variant.class, variantName);
                                 context.configureVariant(variant, action);
                             });
                         }
                         @Override
                         public void whenAvailable(Action<? super OutgoingVariantsContext> action) {
                             deferred.whenResolved(handler -> action.execute(handler));
                         }
                         @Override
                         public void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action) {
                             deferred.whenResolved(registry -> registry.whenOutgoingConfiguration(action));
                         }
                         @Override
                         public void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action) {
                             deferred.whenResolved(registry -> registry.whenOutgoingSlot(action));
                         }
                     };
                     extensions.add(VariantArtifactsExtension.class, "variantArtifacts", variantArtifacts);
                 }
             }

variants/src/main/java/org/implab/gradle/variants/VariantSourcesPlugin.java +4 -4

             package org.implab.gradle.variants;
             import java.util.Objects;
             import java.util.function.Predicate;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.common.core.lang.Strings;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsExtension;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.implab.gradle.variants.sources.CompileUnitsView;
             import org.implab.gradle.variants.sources.GenericSourceSet;
             import org.implab.gradle.variants.sources.RoleProjectionsView;
             import org.implab.gradle.variants.sources.VariantSourcesContext;
             import org.implab.gradle.variants.sources.VariantSourcesExtension;
             import org.implab.gradle.variants.sources.internal.CompileUnitNamer;
             import org.implab.gradle.variants.sources.internal.DefaultCompileUnitNamingPolicy;
             import org.implab.gradle.variants.sources.internal.DefaultLateConfigurationPolicySpec;
             import org.implab.gradle.variants.sources.internal.DefaultVariantSourcesContext;
             import org.implab.gradle.variants.sources.internal.SourceSetConfigurationRegistry;
             import org.implab.gradle.variants.sources.internal.SourceSetRegistry;
             @NonNullByDefault
             public abstract class VariantSourcesPlugin implements Plugin<Project> {
                 public static final String VARIANT_SOURCES_EXTENSION = "variantSources";
                 @Override
                 public void apply(Project target) {
                     var extensions = target.getExtensions();
                     // Apply the main VariantsPlugin to ensure the core variant model is available.
                     target.getPlugins().apply(VariantsPlugin.class);
                     // Access the VariantsExtension to configure variant sources.
                     var variantsExtension = extensions.getByType(VariantsExtension.class);
                     var objectFactory = target.getObjects();
                     var deferred = new Deferred<VariantSourcesContext>();
                     var lateConfigurationPolicy = new DefaultLateConfigurationPolicySpec();
                     var namingPolicy = new DefaultCompileUnitNamingPolicy();
                     variantsExtension.whenFinalized(variants -> {
                         // create variant views
                         var compileUnits = CompileUnitsView.of(variants);
                         var roleProjections = RoleProjectionsView.of(variants);
                         // create registries
                         var sourceSetRegistry = new SourceSetRegistry(objectFactory);
                         lateConfigurationPolicy.finalizePolicy();
                         var sourceSetConfiguration = new SourceSetConfigurationRegistry(lateConfigurationPolicy::mode);
                         // build compile unit namer
                         var compileUnitNamer = CompileUnitNamer.builder()
                             .addUnits(compileUnits.getUnits())
                             .nameCollisionPolicy(namingPolicy.policy())
                             .build();
                         // create the context
                         var context = new DefaultVariantSourcesContext(
                             variants,
                             compileUnits,
                             roleProjections,
                             compileUnitNamer,
                             sourceSetRegistry,
                             sourceSetConfiguration
                         );
                         deferred.resolve(context);
                     });
                     var variantSourcesExtension = new VariantSourcesExtension() {
                         @Override
-                        public void whenFinalized(Action<? super VariantSourcesContext> action) {
+                        public void whenAvailable(Action<? super VariantSourcesContext> action) {
                             deferred.whenResolved(action::execute);
                         }
                         @Override
                         public void lateConfigurationPolicy(Action<? super LateConfigurationPolicySpec> action) {
                             action.execute(lateConfigurationPolicy);
                         }
                         @Override
                         public void namingPolicy(Action<? super NamingPolicySpec> action) {
                             action.execute(namingPolicy);
                         }
                         @Override
                         public void variant(String variantName, Action<? super GenericSourceSet> action) {
                             Strings.argumentNotNullOrBlank(variantName, "variantName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
-                            whenFinalized(ctx -> ctx.configureVariant(resolveVariant(ctx.getVariants(), variantName), action));
+                            whenAvailable(ctx -> ctx.configureVariant(resolveVariant(ctx.getVariants(), variantName), action));
                         }
                         @Override
                         public void layer(String layerName, Action<? super GenericSourceSet> action) {
                             // protect external DSL
                             Strings.argumentNotNullOrBlank(layerName, "layerName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
-                            whenFinalized(ctx -> ctx.configureLayer(resolveLayer(ctx.getVariants(), layerName), action));
+                            whenAvailable(ctx -> ctx.configureLayer(resolveLayer(ctx.getVariants(), layerName), action));
                         }
                         @Override
                         public void unit(String variantName, String layerName, Action<? super GenericSourceSet> action) {
                             Strings.argumentNotNullOrBlank(layerName, "layerName");
                             Strings.argumentNotNullOrBlank(variantName, "variantName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
-                            whenFinalized(ctx -> ctx.configureUnit(resolveCompileUnit(ctx, variantName, layerName), action));
+                            whenAvailable(ctx -> ctx.configureUnit(resolveCompileUnit(ctx, variantName, layerName), action));
                         }
                     };
                     extensions.add(VariantSourcesExtension.class, VARIANT_SOURCES_EXTENSION, variantSourcesExtension);
                 }
                 private static Layer resolveLayer(VariantsView variants, String name) {
                     return variants.getLayers().stream()
                             .filter(named(name))
                             .findAny()
                             .orElseThrow(() -> new InvalidUserDataException("Layer '" + name + "' isn't declared"));
                 }
                 private static Variant resolveVariant(VariantsView variants, String name) {
                     return variants.getVariants().stream()
                             .filter(named(name))
                             .findAny()
                             .orElseThrow(() -> new InvalidUserDataException("Variant '" + name + "' isn't declared"));
                 }
                 private static CompileUnit resolveCompileUnit(VariantSourcesContext ctx, String variantName, String layerName) {
                     return ctx.getCompileUnits().findUnit(
                             resolveVariant(ctx.getVariants(), variantName),
                             resolveLayer(ctx.getVariants(), layerName))
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "The CompileUnit isn't declared for variant '" + variantName + "', layer '" + layerName + "'"));
                 }
                 private static Predicate<Named> named(String name) {
                     return named -> named.getName().equals(name);
                 }
             }

variants/src/main/java/org/implab/gradle/variants/VariantsPlugin.java +1 -1

             package org.implab.gradle.variants;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.core.lang.Deferred;
-            import org.implab.gradle.internal.IdentityContainerFactory;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantDefinition;
             import org.implab.gradle.variants.core.VariantsExtension;
             import org.implab.gradle.variants.core.VariantsView;
+            import org.implab.gradle.variants.internal.IdentityContainerFactory;
             /**
              * <ul>
              * <li> {@link Variant} defines compilation semantics
              * <li> {@link Layer} defines compilation partition
              * <li> {@link Role} defines result grouping / publication intent
              * </ul>
              *
              */
             public abstract class VariantsPlugin implements Plugin<Project> {
                 @Override
                 public void apply(Project target) {
                     var objectFactory = target.getObjects();
                     var variantsExtension = new DefaultVariantsExtension(objectFactory);
                     target.getExtensions().add(VariantsExtension.class, "variants", variantsExtension);
                     target.afterEvaluate(t -> variantsExtension.finalizeExtension());
                 }
                 static class DefaultVariantsExtension implements VariantsExtension {
                     private final NamedDomainObjectContainer<Layer> layers;
                     private final NamedDomainObjectContainer<Role> roles;
                     private final NamedDomainObjectContainer<VariantDefinition> variantDefinitions;
                     private final Deferred<VariantsView> finalizedResult = new Deferred<>();
                     private final ObjectFactory objectFactory;
                     private boolean finalized = false;
                     public DefaultVariantsExtension(ObjectFactory objectFactory) {
                         this.objectFactory = objectFactory;
                         this.layers = IdentityContainerFactory.create(objectFactory, Layer.class);
                         this.roles = IdentityContainerFactory.create(objectFactory, Role.class);
                         this.variantDefinitions = objectFactory.domainObjectContainer(VariantDefinition.class);
                     }
                     @Override
                     public NamedDomainObjectContainer<Layer> getLayers() {
                         return layers;
                     }
                     @Override
                     public NamedDomainObjectContainer<Role> getRoles() {
                         return roles;
                     }
                     @Override
                     public NamedDomainObjectContainer<VariantDefinition> getVariantDefinitions() {
                         return variantDefinitions;
                     }
                     @Override
                     public void whenFinalized(Action<? super VariantsView> action) {
                         finalizedResult.whenResolved(action::execute);
                     }
                     void finalizeExtension() {
                         if (finalized)
                             return;
                         finalized = true;
                         // freeze defined variants
                         variantDefinitions.forEach(VariantDefinition::finalizeVariant);
                         // build a snapshot
                         var viewBuilder = VariantsView.builder();
                         // calculate and add variants
                         variantDefinitions.stream()
                                 .map(def -> objectFactory.named(Variant.class, def.getName()))
                                 .forEach(viewBuilder::addVariant);
                         // add layers
                         layers.forEach(viewBuilder::addLayer);
                         // add roles
                         roles.forEach(viewBuilder::addRole);
                         // add definitions
                         variantDefinitions.forEach(viewBuilder::addDefinition);
                         // assemble the view
                         var view = viewBuilder.build();
                         // set the result and call hooks
                         finalizedResult.resolve(view);
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/OutgoingRegistry.java +1 -1

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.LinkedHashMap;
             import java.util.Map;
             import java.util.Optional;
             import java.util.Set;
             import java.util.function.Consumer;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.artifacts.ConfigurationContainer;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Property;
-            import org.implab.gradle.internal.IdentityContainerFactory;
             import org.implab.gradle.common.core.lang.ReplayableQueue;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
             import org.implab.gradle.variants.artifacts.Slot;
             import org.implab.gradle.variants.core.Variant;
+            import org.implab.gradle.variants.internal.IdentityContainerFactory;
             /**
              * Registry of variant-level outgoing models.
              *
              * <p>Each declared outgoing model owns one lazy Gradle consumable configuration
              * and one live slot identity container.
              */
             @NonNullByDefault
             public class OutgoingRegistry {
                 private final Map<Variant, OutgoingVariant> outgoingByVariant = new LinkedHashMap<>();
                 private final ReplayableQueue<OutgoingVariant> outgoingVariants = new ReplayableQueue<>();
                 private final ConfigurationContainer configurations;
                 private final ObjectFactory objects;
                 private final Set<Variant> declaredVariants;
                 public OutgoingRegistry(
                         ConfigurationContainer configurations,
                         ObjectFactory objects,
                         Set<Variant> declaredVariants) {
                     this.configurations = configurations;
                     this.objects = objects;
                     this.declaredVariants = declaredVariants;
                 }
                 public Optional<OutgoingVariant> find(Variant variant) {
                     return Optional.ofNullable(outgoingByVariant.get(variant));
                 }
                 public OutgoingVariant maybeCreate(Variant variant) {
                     return find(variant).orElseGet(() -> create(variant));
                 }
                 public OutgoingVariant create(Variant variant) {
                     if (!declaredVariants.contains(variant))
                         throw new InvalidUserDataException("Variant " + variant + " isn't declared");
                     if (outgoingByVariant.containsKey(variant))
                         throw new InvalidUserDataException("Outgoing variant " + variant + " already exists");
                     var configuration = configurations.consumable(outgoingConfigurationName(variant));
                     var outgoing = new Outgoing(variant, configuration);
                     outgoingByVariant.put(variant, outgoing);
                     outgoingVariants.add(outgoing);
                     return outgoing;
                 }
                 /**
                  * Registers a replayable hook for outgoing variant declarations.
                  *
                  * @param action outgoing variant action
                  */
                 public void configureEach(Consumer<? super OutgoingVariant> action) {
                     outgoingVariants.forEach(action);
                 }
                 private String outgoingConfigurationName(Variant variant) {
                     return variant.getName() + "Elements";
                 }
                 private class Outgoing implements OutgoingVariant {
                     private final Variant variant;
                     private final NamedDomainObjectProvider<? extends Configuration> configurationProvider;
                     private final NamedDomainObjectContainer<Slot> slots;
                     private final Property<Slot> primarySlot;
                     public Outgoing(
                             Variant variant,
                             NamedDomainObjectProvider<? extends Configuration> configurationProvider) {
                         this.variant = variant;
                         this.configurationProvider = configurationProvider;
                         this.slots = IdentityContainerFactory.create(objects, Slot.class);
                         this.primarySlot = objects.property(Slot.class);
                         primarySlot.finalizeValueOnRead();
                     }
                     @Override
                     public Property<Slot> getPrimarySlot() {
                         return primarySlot;
                     }
                     @Override
                     public Variant getVariant() {
                         return variant;
                     }
                     @Override
                     public NamedDomainObjectProvider<? extends Configuration> getConfiguration() {
                         return configurationProvider;
                     }
                     @Override
                     public NamedDomainObjectContainer<Slot> getSlots() {
                         return slots;
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesExtension.java +10 -10

             package org.implab.gradle.variants.sources;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             @NonNullByDefault
             public interface VariantSourcesExtension {
                 /**
                  * Selects how selector rules behave when they target an already materialized
                  * {@link GenericSourceSet}.
                  *
                  * <p>This policy is single-valued:
                  * <ul>
                  * <li>it must be selected before the first selector rule is registered via
                  * {@link #variant(String, Action)}, {@link #layer(String, Action)} or
                  * {@link #unit(String, String, Action)};</li>
-                 * <li>it must be selected before the finalized context becomes observable via
+                 * <li>it must be selected before the source context becomes observable via
-                 * {@link #whenFinalized(Action)};</li>
+                 * {@link #whenAvailable(Action)};</li>
-                 * <li>once selected or once the finalized context is being created, it cannot
+                 * <li>once selected or once source context creation begins, it cannot
                  * be changed later;</li>
                  * <li>the policy controls both diagnostics and late-application semantics.</li>
                  * </ul>
                  *
                  * <p>If not selected explicitly, the default is
                  * {@link LateConfigurationPolicySpec#failOnLateConfiguration()}.
                  */
                 void lateConfigurationPolicy(Action<? super LateConfigurationPolicySpec> action);
                 default void lateConfigurationPolicy(Closure<?> closure) {
                     lateConfigurationPolicy(Closures.action(closure));
                 }
                 /**
-                 * Selects how compile-unit name collisions are handled when the finalized
+                 * Selects how compile-unit name collisions are handled when the source
-                 * source context is created.
+                 * context is created from the finalized variant model.
                  *
                  * <p>This policy is single-valued:
                  * <ul>
                  * <li>it must be selected before the finalized
                  * {@link VariantSourcesContext} becomes observable through
-                 * {@link #whenFinalized(Action)};</li>
+                 * {@link #whenAvailable(Action)};</li>
                  * <li>once the context is being created, the policy is fixed and cannot be
                  * changed later;</li>
                  * <li>the policy governs validation of compile-unit names produced by the
                  * source-set materializer.</li>
                  * </ul>
                  *
                  * <p>If not selected explicitly, the default is
                  * {@link NamingPolicySpec#failOnNameCollision()}.
                  */
                 void namingPolicy(Action<? super NamingPolicySpec> action);
                 default void namingPolicy(Closure<?> closure) {
                     namingPolicy(Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for all compile units of the given layer.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
                 void layer(String layerName, Action<? super GenericSourceSet> action);
                 default void layer(String layerName, Closure<?> closure) {
                     layer(layerName, Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for all compile units of the given variant.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
                 void variant(String variantName, Action<? super GenericSourceSet> action);
                 default void variant(String variantName, Closure<?> closure) {
                     variant(variantName, Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for one exact compile unit.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
                 void unit(String variantName, String layerName, Action<? super GenericSourceSet> action);
                 default void unit(String variantName, String layerName, Closure<?> closure) {
                     unit(variantName, layerName, Closures.action(closure));
                 }
                 /**
-                 * Invoked when finalized variants-derived source context becomes available.
+                 * Invoked when the variants-derived source context becomes available.
                  *
                  * Replayable:
                  * <ul>
                  * <li>if called before variants finalization, action is queued
                  * <li>if called after variants finalization, action is invoked immediately
                  * </ul>
                  *
                  * <p>By the time this callback becomes observable, compile-unit naming
                  * policy has already been fixed and symbolic source-set names for finalized
                  * compile units are determined.
                  */
-                void whenFinalized(Action<? super VariantSourcesContext> action);
+                void whenAvailable(Action<? super VariantSourcesContext> action);
-                default void whenFinalized(Closure<?> closure) {
+                default void whenAvailable(Closure<?> closure) {
-                    whenFinalized(Closures.action(closure));
+                    whenAvailable(Closures.action(closure));
                 }
                 /**
                  * Imperative selector for the late-configuration mode.
                  *
                  * <p>Exactly one mode is expected to be chosen for the extension lifecycle.
                  */
                 interface LateConfigurationPolicySpec {
                     /**
                      * Rejects selector registration if it targets any already materialized
                      * source set.
                      */
                     void failOnLateConfiguration();
                     /**
                      * Allows late selector registration, but emits a warning when it targets an
                      * already materialized source set.
                      *
                      * <p>For such targets, selector precedence is not re-established
                      * retroactively. The action is applied as a late imperative step, after the
                      * state already produced at the materialization moment.
                      */
                     void warnOnLateConfiguration();
                     /**
                      * Allows late selector registration without a warning when it targets an
                      * already materialized source set.
                      *
                      * <p>For such targets, selector precedence is not re-established
                      * retroactively. The action is applied as a late imperative step, after the
                      * state already produced at the materialization moment.
                      */
                     void allowLateConfiguration();
                 }
                 interface NamingPolicySpec {
                     /**
                      * Rejects finalized compile-unit models that project the same source-set
                      * name for different compile units.
                      */
                     void failOnNameCollision();
                     /**
                      * Resolves name collisions deterministically for the finalized
                      * compile-unit model.
                      *
                      * <p>Conflicting compile units are ordered canonically by
                      * {@code (variant.name, layer.name)}. The first unit keeps the base
                      * projected name, and each next unit receives a numeric suffix
                      * ({@code 2}, {@code 3}, ...).
                      */
                     void resolveNameCollision();
                 }
             }

variants/src/test/java/org/implab/gradle/variants/VariantSourcesPluginFunctionalTest.java +9 -9

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import org.gradle.testkit.runner.BuildResult;
             import org.junit.jupiter.api.Test;
             class VariantSourcesPluginFunctionalTest extends AbstractFunctionalTest {
                 @Test
                 void exposesDerivedViewsAndStableSourceSetProvider() throws Exception {
                     writeSettings("variant-sources-derived-views");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.roles.create('test')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                                 role('test') { layers('main', 'test') }
                             }
                             def lines = []
-                            variantSources.whenFinalized { ctx ->
+                            variantSources.whenAvailable { ctx ->
                                 lines << "units=" + ctx.compileUnits.units
                                     .collect { "${it.variant().name}:${it.layer().name}" }
                                     .sort()
                                     .join(',')
                                 def browser = ctx.variants.variants.find { it.name == 'browser' }
                                 def production = ctx.variants.roles.find { it.name == 'production' }
                                 def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                 def projection = ctx.roleProjections.requireProjection(browser, production)
                                 def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                 def left = ctx.sourceSets.getSourceSet(unit)
                                 def right = ctx.sourceSets.getSourceSet(unit)
                                 lines << "projectionUnits=" + ctx.roleProjections.getUnits(projection)
                                     .collect { it.layer().name }
                                     .sort()
                                     .join(',')
                                 lines << "mainSourceSet=" + left.name
                                 lines << "sameProvider=" + left.is(right)
                             }
                             afterEvaluate {
-                                variantSources.whenFinalized { ctx ->
+                                variantSources.whenAvailable { ctx ->
                                     lines << "late:variants=" + ctx.variants.variants.collect { it.name }.sort().join(',')
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     lines.each { println(it) }
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("units=browser:main,browser:test"));
                     assertTrue(result.getOutput().contains("projectionUnits=main"));
                     assertTrue(result.getOutput().contains("mainSourceSet=browserMain"));
                     assertTrue(result.getOutput().contains("sameProvider=true"));
                     assertTrue(result.getOutput().contains("late:variants=browser"));
                 }
                 @Test
                 void appliesSelectorPrecedenceForFutureMaterialization() throws Exception {
                     writeSettings("variant-sources-precedence");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.roles.create('test')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                                 role('test') { layers('main', 'test') }
                             }
                             variantsExt.variant('node') {
                                 role('production') { layers('main') }
                             }
                             def events = []
                             variantSources {
                                 variant('browser') {
                                     events << "variant:" + name
                                 }
                                 layer('main') {
                                     events << "layer:" + name
                                 }
                                 unit('browser', 'main') {
                                     events << "unit:" + name
                                 }
                             }
                             afterEvaluate {
-                                variantSources.whenFinalized { ctx ->
+                                variantSources.whenAvailable { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def node = ctx.variants.variants.find { it.name == 'node' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def testLayer = ctx.variants.layers.find { it.name == 'test' }
                                     def browserMain = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(browser, mainLayer)).get()
                                     def browserTest = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(browser, testLayer)).get()
                                     def nodeMain = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(node, mainLayer)).get()
                                     def bySourceSet = events.groupBy { it.split(':', 2)[1] }
                                     println("browserMain=" + bySourceSet[browserMain.name].collect { it.split(':', 2)[0] }.join(','))
                                     println("browserTest=" + bySourceSet[browserTest.name].collect { it.split(':', 2)[0] }.join(','))
                                     println("nodeMain=" + bySourceSet[nodeMain.name].collect { it.split(':', 2)[0] }.join(','))
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("browserMain=variant,layer,unit"));
                     assertTrue(result.getOutput().contains("browserTest=variant"));
                     assertTrue(result.getOutput().contains("nodeMain=layer"));
                 }
                 @Test
                 void failsLateConfigurationByDefaultAfterMaterialization() throws Exception {
                     writeSettings("variant-sources-late-fail");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             afterEvaluate {
-                                variantSources.whenFinalized { ctx ->
+                                variantSources.whenAvailable { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                     ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
                                         declareOutputs('late')
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Source sets for [layer=main] layer already materialized", "help");
                 }
                 @Test
                 void allowsLateConfigurationWhenSelectedBeforeFirstSelector() throws Exception {
                     writeSettings("variant-sources-late-allow");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             afterEvaluate {
-                                variantSources.whenFinalized { ctx ->
+                                variantSources.whenAvailable { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                     def sourceSet = ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
                                         declareOutputs('late')
                                     }
                                     sourceSet.output('late')
                                     println('lateAllowed=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("lateAllowed=ok"));
                 }
                 @Test
                 void warnsAndAppliesLateConfigurationWhenWarnModeSelected() throws Exception {
                     writeSettings("variant-sources-late-warn");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 lateConfigurationPolicy {
                                     warnOnLateConfiguration()
                                 }
                             }
                             afterEvaluate {
-                                variantSources.whenFinalized { ctx ->
+                                variantSources.whenAvailable { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                     def sourceSet = ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
                                         declareOutputs('late')
                                     }
                                     sourceSet.output('late')
                                     println('lateWarn=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("Source sets for [layer=main] layer already materialized"));
                     assertTrue(result.getOutput().contains("lateWarn=ok"));
                 }
                 @Test
                 void rejectsChangingLateConfigurationPolicyAfterFirstSelector() throws Exception {
                     writeSettings("variant-sources-late-policy-fixed");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 variant('browser') {
                                     declareOutputs('js')
                                 }
                                 lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             """);
                     assertBuildFails("Lazy configuration policy already applied", "help");
                 }
                 @Test
                 void failsOnProjectedNameCollisionByDefault() throws Exception {
                     writeSettings("variant-sources-name-collision-fail");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('variantBar')
                             variantsExt.layers.create('bar')
                             variantsExt.roles.create('production')
                             variantsExt.variant('foo') {
                                 role('production') { layers('variantBar') }
                             }
                             variantsExt.variant('fooVariant') {
                                 role('production') { layers('bar') }
                             }
                             """);
                     assertBuildFails("The same source set names are produced by different compile units", "help");
                 }
                 @Test
                 void resolvesProjectedNameCollisionDeterministicallyWhenConfigured() throws Exception {
                     writeSettings("variant-sources-name-collision-resolve");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('variantBar')
                             variantsExt.layers.create('bar')
                             variantsExt.roles.create('production')
                             variantsExt.variant('foo') {
                                 role('production') { layers('variantBar') }
                             }
                             variantsExt.variant('fooVariant') {
                                 role('production') { layers('bar') }
                             }
                             variantSources {
                                 namingPolicy {
                                     resolveNameCollision()
                                 }
                             }
                             afterEvaluate {
-                                variantSources.whenFinalized { ctx ->
+                                variantSources.whenAvailable { ctx ->
                                     def foo = ctx.variants.variants.find { it.name == 'foo' }
                                     def fooVariant = ctx.variants.variants.find { it.name == 'fooVariant' }
                                     def variantBar = ctx.variants.layers.find { it.name == 'variantBar' }
                                     def bar = ctx.variants.layers.find { it.name == 'bar' }
                                     def later = ctx.compileUnits.requireUnit(fooVariant, bar)
                                     def earlier = ctx.compileUnits.requireUnit(foo, variantBar)
                                     println("map1=" + later.variant().name + ":" + later.layer().name + "->" + ctx.sourceSets.getSourceSet(later).name)
                                     println("map2=" + earlier.variant().name + ":" + earlier.layer().name + "->" + ctx.sourceSets.getSourceSet(earlier).name)
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("map1=fooVariant:bar->fooVariantBar2"));
                     assertTrue(result.getOutput().contains("map2=foo:variantBar->fooVariantBar"));
                 }
                 @Test
                 void failsOnUnknownVariantSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-variant");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 variant('missing') {
                                     declareOutputs('js')
                                 }
                             }
                             """);
                     assertBuildFails("Variant 'missing' isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownLayerSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-layer");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 layer('missing') {
                                     declareOutputs('js')
                                 }
                             }
                             """);
                     assertBuildFails("Layer 'missing' isn't declared", "help");
                 }
                 @Test
                 void failsOnUndeclaredCompileUnitSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-unit");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 unit('browser', 'test') {
                                     declareOutputs('js')
                                 }
                             }
                             """);
                     assertBuildFails("The CompileUnit isn't declared for variant 'browser', layer 'test'", "help");
                 }
                 @Test
                 void rejectsChangingNamingPolicyAfterContextBecomesObservable() throws Exception {
                     writeSettings("variant-sources-name-policy-fixed");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
-                            variantSources.whenFinalized {
+                            variantSources.whenAvailable {
                                 variantSources.namingPolicy {
                                     resolveNameCollision()
                                 }
                             }
                             """);
                     assertBuildFails("Naming policy already applied", "help");
                 }
                 @Test
                 void rejectsChangingLateConfigurationPolicyAfterContextBecomesObservable() throws Exception {
                     writeSettings("variant-sources-late-policy-context-fixed");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
-                            variantSources.whenFinalized {
+                            variantSources.whenAvailable {
                                 variantSources.lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             """);
                     assertBuildFails("Lazy configuration policy already applied", "help");
                 }
             }

variants/src/main/java/org/implab/gradle/internal/IdentityContainerFactory.java removed 0 -14

	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