implab/gradle-common Commit - r55:a06b08ec0a7f

variants: stabilize artifact slot materialization

cin -

r55:a06b08ec0a7f default

parent child

Context file:

r55:a06b08ec0a7f

Collapse all files

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();
+                        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 -> {
                             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/artifacts/ArtifactAssemblies.java +6 -1

             package org.implab.gradle.variants.artifacts;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             /**
              * Resolves stateful slot assemblies from cheap slot identities.
              *
              * <p>
              * The returned assembly is a materialized build-model handle. It may expose
              * lazy Gradle providers, but
              * it is no longer an identity object suitable for replayable discovery.
              */
             @NonNullByDefault
             public interface ArtifactAssemblies {
                 /**
                  * Resolves the assembly for the given slot.
                  *
                  * <p>
                  * This call materializes the build-facing body of the slot from its identity.
                  *
                  * @param slot slot identity inside a variant outgoing contract
                  * @return assembly handle for the slot
                  */
                 default ArtifactAssembly require(ArtifactSlot slot) {
                     return find(slot)
                             .orElseThrow(() -> new InvalidUserDataException("Artifact assembly '" + slot + "' isn't registered"));
                 }
                 /**
                  * Registers a configuration action for the assembly of the given slot.
                  *
                  * <p>If the assembly is already registered, the action is invoked immediately.
                  * Otherwise, it is queued and invoked when slot materialization registers the
                  * assembly handle.
                  *
                  * @param slot slot identity inside a variant outgoing contract
                  * @param action assembly configuration action
                  */
                 void when(ArtifactSlot slot, Action<? super ArtifactAssembly> action);
                 /**
                  * Adds global configuration action for all materialized assemblies. If some assemblies are
                  * already registered, the action will be invoked for them immediately. For assemblies that
                  * are materialized later, the action will be invoked when they are registered.
                  *
                  * @param action assembly configuration action.
                  */
                 void configureEach(Action<? super ArtifactAssembly> action);
-                /** Ищет зарегистрированный слот */
+                /**
+                 * Finds a registered assembly for the given slot identity.
+                 *
+                 * @param slot slot identity inside a variant outgoing contract
+                 * @return registered assembly, if the slot body has already been materialized
+                 */
                 Optional<ArtifactAssembly> find(ArtifactSlot slot);
             }

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

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Action;
             import org.gradle.api.artifacts.Configuration;
             import org.implab.gradle.common.core.lang.Closures;
             import org.implab.gradle.variants.core.Variant;
             import groovy.lang.Closure;
             /**
              * Materialized root outgoing configuration of a variant.
              *
              * <p>This is a variant-level publication hook. Slot-specific publication state is exposed separately via
-             * {@link OutgoingArtifactSlotSpec}.
+             * {@link OutgoingConfigurationSlotSpec}.
              */
             public interface OutgoingConfigurationSpec {
                 /**
                  * Returns the variant whose outgoing configuration is represented here.
                  *
                  * @return variant identity
                  */
                 Variant getVariant();
                 /**
                  * Returns the root consumable outgoing configuration of the variant.
                  *
                  * @return outgoing configuration
                  */
                 Configuration getConfiguration();
                 /**
                  * Applies a configuration action to the root outgoing configuration.
                  *
                  * @param action configuration action
                  */
                 default void configuration(Action<? super Configuration> action) {
                     action.execute(getConfiguration());
                 }
                 default void configuration(Closure<?> closure) {
                     configuration(Closures.action(closure));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariant.java +27 -14

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.provider.Property;
             import org.implab.gradle.variants.core.Variant;
             /**
-             * Описывает исходящую конфигурацию варианта
+             * Plugin model object for one variant-level outgoing contract.
              *
-             * Задает связь между моделью вариантов и моделью конфигураций gradle через
+             * <p>An outgoing variant connects a core {@link Variant} identity with the lazy
-             * свойство {@link #getConfiguration()}. Также задает отдельную ось слотов
+             * Gradle consumable configuration registered for that variant. It also exposes a
-             * публикации, но не задает правил связывания этих слотов с самой конфигурацией
+             * live container of slot identities. Slot identities are only declarations and do
-             * и их содержимым. Самый простой вариант это {@link ArtifactAssemblies}.
+             * not imply that a Gradle outgoing artifact variant or an {@link ArtifactAssembly}
+             * has been materialized.
              */
             public interface OutgoingVariant {
                 /**
-                 * Исходный вариант для которого строится Outgoing конфигурация
+                 * Returns the variant that owns this outgoing contract.
+                 *
+                 * @return variant identity
                  */
                 Variant getVariant();
                 /**
-                 * Провайдер зарегистрированной конфигурации
+                 * Returns the provider of the registered consumable outgoing configuration.
+                 *
+                 * @return outgoing configuration provider
                  */
                 NamedDomainObjectProvider<? extends Configuration> getConfiguration();
+                /**
+                 * Configures the registered outgoing configuration.
+                 *
+                 * @param action configuration action
+                 */
                 default void configureOutgoing(Action<? super Configuration> action) {
                     getConfiguration().configure(action);
                 }
                 /**
-                 * Слоты конфигурации, данная коллекция живая, используется для
+                 * Returns the live slot identity container.
-                 * получения информации об объявленных слотах, но эти слоты не
-                 * обязаны быть сконфигурированы, т.е. это только Identity.
+                 * <p>This collection is intended for discovery and selection. Slot presence does
+                 * not guarantee that the slot has a configured assembly body or a materialized
+                 * Gradle outgoing artifact variant.
                  *
                  * @see {@link ArtifactSlot}
                  */
                 NamedDomainObjectContainer<Slot> getSlots();
                 /**
-                 * Основной набор артефактов (primary variant) для исходящей конфигурации
+                 * Returns the primary slot property.
                  *
-                 * <p>
+                 * <p>If exactly one slot is declared, the single-slot convention uses that slot as
-                 * Если в свойстве {@link #getSlots()} есть только один слой, то по конвенции он
+                 * the primary one. Reading this property finalizes the selected primary slot.
-                 * считается также основным.
+                 * @return primary slot property
                  */
                 Property<Slot> getPrimarySlot();
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariantsContext.java +54 -3

@@ -1,36 +1,87
1	package org.implab.gradle.variants.artifacts;	1	package org.implab.gradle.variants.artifacts;
2		2
3	import java.util.Optional;	3	import java.util.Optional;
4		4
5	import org.gradle.api.Action;	5	import org.gradle.api.Action;
6	import org.gradle.api.InvalidUserDataException;	6	import org.gradle.api.InvalidUserDataException;
7	import org.implab.gradle.variants.core.Variant;	7	import org.implab.gradle.variants.core.Variant;
8		8
9	/**	9	/**
10	* Контекст работы с вариантами публикации, становится доступным после	10	* Live context for declaring and observing variant outgoing publications.
11	* финализации модели вариантов. Фактически является живой моделью	11	*
		12	* <p>The context becomes available after the core variant model has been finalized.
		13	* It owns variant-level outgoing declarations, assembly lookup, and hooks for
		14	* materialized Gradle-facing publication state.
12	*/	15	*/
13	public interface OutgoingVariantsContext {	16	public interface OutgoingVariantsContext {
14		17
		18	/**
		19	* Returns the assembly lookup service.
		20	*
		21	* <p>Assemblies are stateful slot bodies resolved from cheap {@link ArtifactSlot}
		22	* identities.
		23	*
		24	* @return assembly lookup service
		25	*/
15	ArtifactAssemblies getAssemblies();	26	ArtifactAssemblies getAssemblies();
16		27
		28	/**
		29	* Configures artifact slots of the given variant.
		30	*
		31	* @param variant variant identity
		32	* @param action variant artifact declaration
		33	*/
17	void configureVariant(Variant variant, Action<? super VariantArtifactsSpec> action);	34	void configureVariant(Variant variant, Action<? super VariantArtifactsSpec> action);
18		35
19	/**	36	/**
20	* Replayable hook для всех объявленных конфигураций	37	* Registers a replayable action for declared outgoing variants.
		38	*
		39	* <p>The action receives the plugin model object, not necessarily a materialized
		40	* Gradle publication. Use {@link #whenOutgoingConfiguration(Action)} and
		41	* {@link #whenOutgoingSlot(Action)} for materialized Gradle-facing state.
		42	*
		43	* @param action outgoing variant action
21	*/	44	*/
22	void configureEach(Action<? super OutgoingVariant> action);	45	void configureEach(Action<? super OutgoingVariant> action);
23		46
		47	/**
		48	* Finds the outgoing model for the given variant.
		49	*
		50	* @param variant variant identity
		51	* @return outgoing model, if declared
		52	*/
24	Optional<OutgoingVariant> findOutgoing(Variant variant);	53	Optional<OutgoingVariant> findOutgoing(Variant variant);
25		54
		55	/**
		56	* Requires the outgoing model for the given variant.
		57	*
		58	* @param variant variant identity
		59	* @return outgoing model
		60	* @throws InvalidUserDataException if the outgoing variant is not declared
		61	*/
26	default OutgoingVariant requireOutgoing(Variant variant) {	62	default OutgoingVariant requireOutgoing(Variant variant) {
27	return findOutgoing(variant)	63	return findOutgoing(variant)
28	.orElseThrow(() -> new InvalidUserDataException("Outgoing variant '" + variant + "' isn't registered"));	64	.orElseThrow(() -> new InvalidUserDataException("Outgoing variant '" + variant + "' isn't registered"));
29	}	65	}
30		66
		67	/**
		68	* Registers a replayable action for materialized variant-level outgoing
		69	* configurations.
		70	*
		71	* @param action materialized outgoing configuration action
		72	*/
31	void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action);	73	void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action);
32		74
		75	/**
		76	* Registers a replayable action for materialized slot publications.
		77	*
		78	* <p>Slot publication hooks follow the Gradle outgoing publication model. A
		79	* declared slot identity by itself does not guarantee that a slot publication has
		80	* been materialized.
		81	*
		82	* @param action materialized slot publication action
		83	*/
33	void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action);	84	void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action);
34		85
35		86
36	}	87	}

variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsSpec.java 0 -2

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Action;
             import groovy.lang.Closure;
             import org.implab.gradle.common.core.lang.Closures;
             /**
              * DSL model for declaring slots of a single variant.
              *
              * <p>The surrounding variant defines the external outgoing contract. Slots declared here define artifact
              * sets within that contract. If a variant exposes more than one slot, one of them is expected to be the
              * primary slot.
              */
             public interface VariantArtifactsSpec {
                 /**
                  * Declares a non-primary slot of the current variant.
                  *
                  * @param name slot name
                  * @param action slot declaration
-                 * @return slot identity
                  */
                 void slot(String name, Action<? super ArtifactAssemblySpec> action);
                 default void slot(String name, Closure<?> closure) {
                     slot(name, Closures.action(closure));
                 }
                 /**
                  * Declares the primary slot of the current variant.
                  *
                  * @param name slot name
                  * @param action slot declaration
-                 * @return slot identity
                  */
                 void primarySlot(String name, Action<? super ArtifactAssemblySpec> action);
                 default void primarySlot(String name, Closure<?> closure) {
                     primarySlot(name, Closures.action(closure));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyBinder.java +9 -9

             package org.implab.gradle.variants.artifacts.internal;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblies;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
             /**
-             * Связывает описание исходящих конфигураций gradle и сборку содержимого слотов
+             * Binds materialized slot assemblies to Gradle outgoing publications.
-             * из {@link ArtifactAssemblies}
              */
             @NonNullByDefault
             public class ArtifactAssemblyBinder implements Action<OutgoingVariant> {
                 private final ArtifactAssemblies resolver;
                 public ArtifactAssemblyBinder(ArtifactAssemblies resolver) {
                     this.resolver = resolver;
                 }
                 @Override
                 public void execute(OutgoingVariant outgoingVariant) {
                     var slots = outgoingVariant.getSlots();
                     var primarySlotProvider = outgoingVariant.getPrimarySlot();
                     var variant = outgoingVariant.getVariant();
-                    // связываем конфигурацию
+                    // Bind publication state when the owning configuration is materialized.
                     outgoingVariant.configureOutgoing(configuration -> {
                         var primarySlot = primarySlotProvider.get();
                         var outgoing = configuration.getOutgoing();
-                        // связываем основной вариант конфигурации
+                        // Bind the primary artifact set to the root outgoing configuration.
                         resolver.when(
                                 new ArtifactSlot(variant, primarySlot),
                                 assembly -> outgoing.artifact(assembly.getArtifact()));
-                        // для всех объявленных слотов
+                        // Bind non-primary slots to Gradle secondary artifact variants.
                         slots.all(slot -> {
-                            // кроме основного
                             if (slot.equals(primarySlot))
                                 return;
-                            // связываем артефакты
                             resolver.when(
                                     new ArtifactSlot(variant, slot),
+                                    // Gradle artifact variants must be created while the owning
+                                    // configuration is being materialized. Lazy registration may
+                                    // otherwise be realized only after dependency resolution starts.
                                     assembly -> outgoing.getVariants()
-                                            .register(slot.getName())
+                                            .create(slot.getName())
-                                            .configure(cv -> cv.artifact(assembly.getArtifact())));
+                                            .artifact(assembly.getArtifact()));
                         });
                     });
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyHandler.java +13 -29

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.HashMap;
             import java.util.HashSet;
             import java.util.Map;
             import java.util.Set;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.file.ConfigurableFileCollection;
             import org.gradle.api.file.Directory;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.FileCollection;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Provider;
             import org.gradle.api.tasks.Sync;
             import org.gradle.api.tasks.TaskContainer;
             import org.gradle.language.base.plugins.LifecycleBasePlugin;
             import org.implab.gradle.common.core.lang.FilePaths;
+            import org.implab.gradle.variants.artifacts.ArtifactAssembly;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.implab.gradle.variants.sources.CompileUnitsView;
             import org.implab.gradle.variants.sources.RoleProjectionsView;
             import org.implab.gradle.variants.sources.SourceSetMaterializer;
             /**
-             * Адаптер между фрагментами артефактов, представленными в виде
+             * Adapts slot contribution declarations to materialized {@link ArtifactAssembly}
-             * {@link SlotContribution},
+             * handles.
-             * и ArtifactAssemblyRegistry, который оперирует уже собранными
-             * {@link ArtifactAssembly}.
              *
-             * Данный класс отвечает за сборку отдельных фрагментов артефактов в единый
+             * <p>The handler creates one {@link Sync} task per {@link ArtifactSlot}. The task
-             * каталог, который затем регистрируется в ArtifactAssemblyRegistry в виде
+             * copies all collected slot inputs into a single output directory. That output
-             * {@link ArtifactAssembly}. Сборка конечного артефакта происходит при помощи
+             * directory is then registered in {@link ArtifactAssemblyRegistry} as the
-             * задачи, которая копирует все входные файлы в выходной каталог. Задача
+             * published artifact for the slot.
-             * создается для каждого {@link ArtifactSlot} и использует
-             * {@link SlotAssembly#inputs()} как источник входных данных.
              *
-             * Для сборки используется паттерн Visitor: каждый фрагмент артефакта
+             * <p>Input collection uses {@link SlotContributionVisitor}. Each contribution is
-             * представлен в виде реализации интерфейса {@link SlotContribution}, который
+             * converted to a {@link SlotInputKey}; duplicate keys are ignored so that repeated
-             * имеет метод accept, принимающий Visitor.
+             * topology-based selections do not add the same input twice.
-             * Visitor реализован во внутреннем классе {@link ContributionVisitor}, который
-             * знает, как обрабатывать каждый тип фрагмента и добавлять его в сборку.
-             * Для каждого {@link SlotContribution} создается ключ {@link SlotInputKey},
-             * который используется для дедупликации: если фрагмент с таким же ключом уже
-             * был добавлен, то он игнорируется.
              */
             @NonNullByDefault
             public class ArtifactAssemblyHandler {
                 private final ObjectFactory objects;
                 private final ArtifactAssemblyRegistry assemblyRegistry;
                 private final DirectoryProperty assembliesDirectory;
                 private final TaskContainer tasks;
                 private final CompileUnitsView compileUnitsView;
                 private final RoleProjectionsView roleProjectionsView;
                 private final SourceSetMaterializer sourceSetMaterializer;
                 private final Map<ArtifactSlot, SlotAssembly> slotInputs = new HashMap<>();
                 public ArtifactAssemblyHandler(
                         ObjectFactory objects,
                         TaskContainer tasks,
                         ArtifactAssemblyRegistry assemblyRegistry,
                         CompileUnitsView compileUnitsView,
                         RoleProjectionsView roleProjectionsView,
                         SourceSetMaterializer sourceSetMaterializer) {
                     this.objects = objects;
                     this.tasks = tasks;
                     this.assemblyRegistry = assemblyRegistry;
                     this.compileUnitsView = compileUnitsView;
                     this.roleProjectionsView = roleProjectionsView;
                     this.sourceSetMaterializer = sourceSetMaterializer;
                     assembliesDirectory = objects.directoryProperty();
                 }
                 public DirectoryProperty getAssembliesDirectory() {
                     return assembliesDirectory;
                 }
                 public void configureAssembly(ArtifactSlot artifactSlot, Action<? super ArtifactAssemblySpec> action) {
                     var visitor = contributionVisitor(artifactSlot);
                     var spec = new DefaultArtifactAssemblySpec(objects, c -> c.accept(visitor));
                     action.execute(spec);
                 }
                 public SlotContributionVisitor contributionVisitor(ArtifactSlot artifactSlot) {
                     var assembly = slotInputs.computeIfAbsent(artifactSlot, this::createSlotAssembly);
                     return new ContributionVisitor(artifactSlot, assembly);
                 }
                 /**
-                 * Создает сборку для указанного слота артефакта, сборка регистрируется в
+                 * Creates the assembly task for the given slot and registers its output artifact.
-                 * ArtifactAssemblyRegistry, если для слота сборка уже была зарегистрирована
-                 * кем-то еще, то возникает ошибка.
                  */
                 private SlotAssembly createSlotAssembly(ArtifactSlot artifactSlot) {
                     var assembly = new SlotAssembly();
                     var fileCollection = assembly.inputs();
                     var outputDirectory = outputDirectory(artifactSlot);
                     var task = tasks.register(assembleTaskName(artifactSlot), Sync.class, copy -> {
                         copy.setGroup(LifecycleBasePlugin.BUILD_GROUP);
                         copy.into(outputDirectory);
                         copy.from(fileCollection);
                     });
                     assemblyRegistry.register(artifactSlot, task, t -> outputDirectory);
                     return assembly;
                 }
                 private String assembleTaskName(ArtifactSlot artifactSlot) {
                     var variantName = artifactSlot.variant().getName();
                     var slotName = artifactSlot.slot().getName();
                     return "assembleVariantArtifactSlot"
                             + "_v" + variantName.length() + "_" + variantName
                             + "_s" + slotName.length() + "_" + slotName;
                 }
                 private Provider<Directory> outputDirectory(ArtifactSlot artifactSlot) {
                     return assembliesDirectory.dir(
                             FilePaths.cat(
                                     artifactSlot.variant().getName(),
                                     artifactSlot.slot().getName()));
                 }
                 /**
-                 * Собирает отдельные фрагменты артефактов в единый источник
+                 * Collects slot contributions into one {@link ConfigurableFileCollection}.
-                 * {@link ConfigurableFileCollection}.
-                 * Для фрагментов {@link SlotContribution} используется механизм дедупликации:
-                 * для каждого
-                 * водящего фрагмента создается ключ {@link SlotInputKey} и добавляются
-                 * фрагменты только
-                 * с уникальным ключом, повторы игнорируются.
                  */
                 private class ContributionVisitor implements SlotContributionVisitor {
                     // artifact slot for this assembly
                     private final ArtifactSlot artifactSlot;
                     // seen inputs, used for deduplication
                     private final SlotAssembly assembly;
                     ContributionVisitor(ArtifactSlot artifactSlot, SlotAssembly assembly) {
                         this.artifactSlot = artifactSlot;
                         this.assembly = assembly;
                     }
                     @Override
                     public void visit(DirectContribution contribution) {
                         contribute(
                                 SlotInputKey.newUniqueKey("Direct input for " + artifactSlot),
                                 contribution.input());
                     }
                     @Override
                     public void visit(VariantOutputsContribution contribution) {
                         var units = compileUnitsView.getUnitsForVariant(artifactSlot.variant());
                         contributeCompileUnits(units, contribution.outputs());
                     }
                     @Override
                     public void visit(RoleOutputsContribution contribution) {
                         var roleProjection = roleProjectionsView.requireProjection(artifactSlot.variant(),
                                 contribution.role());
                         var units = roleProjectionsView.getUnits(roleProjection);
                         contributeCompileUnits(units, contribution.outputs());
                     }
                     @Override
                     public void visit(LayerOutputsContribution contribution) {
                         var unit = compileUnitsView.requireUnit(artifactSlot.variant(), contribution.layer());
                         contributeCompileUnits(Set.of(unit), contribution.outputs());
                     }
                     private void contributeCompileUnits(Set<CompileUnit> units, Set<String> outputs) {
                         units.stream()
                                 // expand variant compile units, make (compileUnit, outputName) pairs
                                 .flatMap(unit -> outputs.stream()
                                         .map(output -> new CompileUnitOutputKey(unit, output)))
                                 .forEach(key -> contribute(
                                         key,
                                         sourceSetMaterializer.getSourceSet(key.unit())
                                                 .map(s -> s.output(key.outputName()))));
                     }
                     private void contribute(SlotInputKey key, Object resolvedInput) {
                         assembly.addSlotInput(key, resolvedInput);
                     }
                 }
-                /** Состояние для отдельного слота */
+                /** Mutable input state for one slot assembly. */
                 class SlotAssembly {
                     private final ConfigurableFileCollection inputs = objects.fileCollection();
                     private final Set<SlotInputKey> seen = new HashSet<>();
                     public void addSlotInput(SlotInputKey key, Object input) {
                         if (!seen.add(key))
                             return;
                         inputs.from(input);
                     }
                     public FileCollection inputs() {
                         return inputs;
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultArtifactAssemblySpec.java +5 -3

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.HashSet;
             import java.util.Set;
             import java.util.function.Consumer;
             import java.util.stream.Stream;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.core.lang.Strings;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.artifacts.OutputSelectionSpec;
             /**
-             * Реализация DSL модели, строит набор {@link SlotContribution}. При построении набора
+             * Default DSL facade for collecting {@link SlotContribution} declarations.
-             * правила и корректность не проверяются. По окончании использования клиент
-             * вызывает метод {@link #process(Consumer)} для обработки результатов.
              *
+             * <p>The spec does not validate topology references immediately. It translates DSL
+             * calls to contribution objects and passes them to the supplied consumer; semantic
+             * validation happens later when the assembly handler resolves contributions
+             * against the finalized source model.
              */
             @NonNullByDefault
             final class DefaultArtifactAssemblySpec implements ArtifactAssemblySpec {
                 private final Consumer<? super SlotContribution> consumer;
                 private final ObjectFactory objectFactory;
                 DefaultArtifactAssemblySpec(ObjectFactory objectFactory, Consumer<? super SlotContribution> consumer) {
                     this.consumer = consumer;
                     this.objectFactory = objectFactory;
                 }
                 @Override
                 public void from(Object artifact) {
                     consumer.accept(new DirectContribution(artifact));
                 }
                 @Override
                 public void fromVariant(Action<? super OutputSelectionSpec> action) {
                     consumer.accept(new VariantOutputsContribution(outputs(action)));
                 }
                 @Override
                 public void fromRole(String roleName, Action<? super OutputSelectionSpec> action) {
                     consumer.accept(new RoleOutputsContribution(
                             objectFactory.named(Role.class, roleName),
                             outputs(action)));
                 }
                 @Override
                 public void fromLayer(String layerName, Action<? super OutputSelectionSpec> action) {
                     consumer.accept(new LayerOutputsContribution(
                             objectFactory.named(Layer.class, layerName),
                             outputs(action)));
                 }
                 private static Set<String> outputs(Action<? super OutputSelectionSpec> action) {
                     var spec = new OutputsSetSpec();
                     action.execute(spec);
                     return spec.outputs();
                 }
                 private static class OutputsSetSpec implements OutputSelectionSpec {
                     private final Set<String> outputs = new HashSet<>();
                     @Override
                     public void output(String name, String... extra) {
                         Stream.concat(Stream.of(name), Stream.of(extra))
                             .map(Strings::requireNonBlank)
                             .forEach(outputs::add);
                     }
                     Set<String> outputs() {
                         return Set.copyOf(outputs);
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/MaterializationPolicyHandler.java +11 -6

             package org.implab.gradle.variants.artifacts.internal;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.attributes.AttributeContainer;
-            import org.implab.gradle.internal.ReplayableQueue;
+            import org.gradle.api.model.ObjectFactory;
+            import org.implab.gradle.common.core.lang.ReplayableQueue;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSlotSpec;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSpec;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
+            import org.implab.gradle.variants.artifacts.Slot;
             import org.implab.gradle.variants.core.Variant;
             /**
              * Handles outgoing artifact materialization policy.
              *
              * <p>Materialization is the phase where the plugin interprets variant artifact
              * declarations as Gradle outgoing publication state: a consumable configuration,
              * its primary artifact set, secondary artifact variants, and attributes.
              *
              * <p>The handler provides extension points for customizing the materialized
              * Gradle-facing objects. These hooks intentionally expose Gradle API objects.
              * This allows advanced customization, but also means that callers can bypass
              * the plugin model. Such customizations are considered caller responsibility.
              *
              * <p>The internal binding mechanics are not part of the public contract. The
              * contract is the materialized outgoing state exposed through the specification
              * objects.
              */
             @NonNullByDefault
             public class MaterializationPolicyHandler implements Action<OutgoingVariant> {
                 private final ReplayableQueue<OutgoingConfigurationSpec> variantMaterialization = new ReplayableQueue<>();
                 private final ReplayableQueue<OutgoingConfigurationSlotSpec> slotMaterialization = new ReplayableQueue<>();
+                private final ObjectFactory objects;
-                public MaterializationPolicyHandler() {
+                public MaterializationPolicyHandler(ObjectFactory objects) {
+                    this.objects = objects;
                 }
                 @Override
                 public void execute(OutgoingVariant outgoingVariant) {
-                    var slots = outgoingVariant.getSlots();
                     var primarySlotProvider = outgoingVariant.getPrimarySlot();
                     var variant = outgoingVariant.getVariant();
-                    // связываем конфигурацию
+                    // Materialization hooks are attached to the owning outgoing configuration.
                     outgoingVariant.configureOutgoing(configuration -> {
                         var primarySlot = primarySlotProvider.get();
                         var outgoing = configuration.getOutgoing();
                         variantMaterialized(variant, configuration);
                         slotMaterialized(new ArtifactSlot(variant, primarySlot), true, outgoing.getAttributes());
-                        slots.forEach(slot -> {
+                        // Slot publication hooks follow materialized Gradle artifact variants,
+                        // not the live slot identity view.
+                        outgoing.getVariants().configureEach(variantConfiguration -> {
+                            var slot = objects.named(Slot.class, variantConfiguration.getName());
                             if (slot.equals(primarySlot))
                                 return;
-                            var variantConfiguration = outgoing.getVariants().getByName(slot.getName());
                             slotMaterialized(new ArtifactSlot(variant, slot), false, variantConfiguration.getAttributes());
                         });
                     });
                 };
                 public void whenVariantMaterialized(Action<? super OutgoingConfigurationSpec> action) {
                     variantMaterialization.forEach(action::execute);
                 }
                 public void whenSlotMaterialized(Action<? super OutgoingConfigurationSlotSpec> action) {
                     slotMaterialization.forEach(action::execute);
                 }
                 private void variantMaterialized(Variant variant, Configuration configuration) {
                     variantMaterialization.add(new OutgoingConfigurationSpec() {
                         @Override
                         public Variant getVariant() {
                             return variant;
                         }
                         @Override
                         public Configuration getConfiguration() {
                             return configuration;
                         }
                     });
                 }
                 private void slotMaterialized(ArtifactSlot slot, boolean primary, AttributeContainer attributes) {
                     slotMaterialization.add(new OutgoingConfigurationSlotSpec() {
                         @Override
                         public boolean isPrimary() {
                             return primary;
                         }
                         @Override
                         public ArtifactSlot getArtifactSlot() {
                             return slot;
                         }
                         @Override
                         public void artifactAttributes(Action<? super AttributeContainer> action) {
                             action.execute(attributes);
                         }
                     });
                 }
             }

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

             package org.implab.gradle.variants.artifacts.internal;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.provider.ProviderFactory;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
             public class SingleSlotConvention implements Action<OutgoingVariant> {
                 private final ProviderFactory providers;
                 public SingleSlotConvention(ProviderFactory providers) {
                     this.providers = providers;
                 }
                 @Override
                 public void execute(OutgoingVariant outgoingVariant) {
                     var slots = outgoingVariant.getSlots();
                     outgoingVariant.getPrimarySlot().convention(
-                            // если есть ровно один слот, то он считается primary
+                            // If exactly one slot is declared, it becomes the primary slot.
                             providers.provider(() -> {
                                 if (slots.size() == 0)
                                     throw new InvalidUserDataException("No slots declared for " + outgoingVariant.getVariant());
                                 if (slots.size() > 1)
                                     throw new InvalidUserDataException("Multiple slots declared for " + outgoingVariant.getVariant() +
                                             ", please specify primary slot explicitly");
                                 return slots.stream().findAny().get();
                             }));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/package-info.java +2 -3

             /**
              * Variant-scoped outgoing artifacts.
              *
              * <p>This package models the external artifact contract of a project in terms of variant-local slots.
              * A variant represents one outgoing contract, while a slot represents one artifact set inside that
              * contract.
              *
              * <p>The model intentionally separates cheap identity objects from stateful build objects:
              *
              * <ul>
              * <li>{@link org.implab.gradle.variants.artifacts.ArtifactSlot} identifies a published slot inside a
              * variant;</li>
              * <li>{@link org.implab.gradle.variants.artifacts.ArtifactAssembly} is the lazily materialized body of
              * that slot.</li>
              * </ul>
              *
              * <p>Each slot is expected to materialize to exactly one published artifact: either one file or one
              * directory. Internal build topology such as roles may participate in slot assembly rules, but does not
              * belong to external artifact identity.
              *
              * <p>Typical usage:
              *
              * <pre>{@code
              * variantArtifacts {
              *     variant("browser") {
              *         primarySlot("runtime") {
              *             fromRole("main") { output("js") }
              *         }
              *         slot("sources") {
              *             fromLayer("main") { output("sources") }
              *         }
              *     }
              * }
              * }</pre>
              *
-             * <p>After finalization, slot identities can be observed through
+             * <p>After finalization, {@link org.implab.gradle.variants.artifacts.OutgoingVariant} exposes declared slot
-             * {@link org.implab.gradle.variants.artifacts.OutgoingVariantsContext#getSlots()}, while slot bodies are
+             * identities through {@code getSlots()}, while slot bodies are obtained on demand through
-             * obtained on demand through
              * {@link org.implab.gradle.variants.artifacts.OutgoingVariantsContext#getAssemblies()}.
              */
             package org.implab.gradle.variants.artifacts;

variants/src/test/java/org/implab/gradle/variants/VariantArtifactsPluginFunctionalTest.java +128 0

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.junit.jupiter.api.Test;
             class VariantArtifactsPluginFunctionalTest extends AbstractFunctionalTest {
                 @Test
                 void gradleReferenceLazyOutgoingConfigurationAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'gradle-reference-outgoing-resolution'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/typesPackage", "types\n");
                     writeFile("producer/inputs/js", "js\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             project(':producer') {
                                 def browserElements = configurations.consumable('browserElements')
                                 println('reference: registered browserElements provider')
                                 browserElements.configure { configuration ->
                                     println('reference: configuring browserElements')
                                     configuration.attributes.attribute(variantAttr, 'browser')
                                     configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
                                     configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
                                     configuration.outgoing.variants.create('js') { secondary ->
                                         println('reference: creating js outgoing variant')
                                         secondary.attributes.attribute(slotAttr, 'js')
                                         secondary.artifact(layout.projectDirectory.file('inputs/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 {
                                         println('reference: resolving primary files')
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         println('reference: resolving secondary files')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     var output = result.getOutput();
                     var registered = output.indexOf("reference: registered browserElements provider");
                     var resolvingPrimary = output.indexOf("reference: resolving primary files");
                     var configuring = output.indexOf("reference: configuring browserElements");
                     var creatingSecondary = output.indexOf("reference: creating js outgoing variant");
                     var resolvingSecondary = output.indexOf("reference: resolving secondary files");
                     assertTrue(registered >= 0);
                     assertTrue(resolvingPrimary >= 0);
                     assertTrue(configuring >= 0);
                     assertTrue(creatingSecondary >= 0);
                     assertTrue(resolvingSecondary >= 0);
                     assertTrue(registered < resolvingPrimary);
                     assertTrue(resolvingPrimary < configuring);
                     assertTrue(configuring < creatingSecondary);
                     assertTrue(creatingSecondary < resolvingSecondary);
                     assertTrue(output.contains("compileFiles=typesPackage"));
                     assertTrue(output.contains("jsFiles=js"));
                 }
                 @Test
+                void gradleReferenceRegisteredSecondaryArtifactVariantIsNotRealizedBeforeResolution() throws Exception {
+                    // Gradle issue: https://github.com/gradle/gradle/issues/27441
+                    // Registered outgoing artifact variants are not realized before dependency resolution.
+                    writeFile("settings.gradle", """
+                            rootProject.name = 'gradle-reference-registered-secondary-variant'
+                            include 'producer', 'consumer'
+                            """);
+                    writeFile("producer/inputs/typesPackage", "types\n");
+                    writeFile("producer/inputs/js", "js\n");
+                    writeFile("build.gradle", """
+                            import org.gradle.api.attributes.Attribute
+                            def variantAttr = Attribute.of('test.variant', String)
+                            def slotAttr = Attribute.of('test.slot', String)
+                            project(':producer') {
+                                def browserElements = configurations.consumable('browserElements')
+                                browserElements.configure { configuration ->
+                                    configuration.attributes.attribute(variantAttr, 'browser')
+                                    configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
+                                    configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
+                                    configuration.outgoing.variants.register('js') { secondary ->
+                                        secondary.attributes.attribute(slotAttr, 'js')
+                                        secondary.artifact(layout.projectDirectory.file('inputs/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)
+                                    }
+                                }
+                            }
+                            """);
+                    assertBuildFails("Cannot create variant 'js' after dependency configuration ':producer:browserElements' has been resolved",
+                            ":consumer:probe");
+                }
+                @Test
                 void materializesPrimaryAndSecondarySlotsAndInvokesOutgoingHooks() throws Exception {
                     writeSettings("variant-artifacts-slots");
                     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");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             variants.layers.create('mainBase')
                             variants.layers.create('mainAmd')
                             variants.roles.create('main')
                             variants.roles.create('test')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
                             }
                             variantSources {
                                 layer('mainBase') {
                                     declareOutputs('js')
                                     registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                 }
                                 layer('mainAmd') {
                                     declareOutputs('js')
                                     registerOutput('js', layout.projectDirectory.file('inputs/amd.js'))
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('mainJs') {
                                         fromRole('main') {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/mainJs.txt'))
                                     }
                                     slot('amdJs') {
                                         fromLayer('mainAmd') {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/amdJs.txt'))
                                     }
                                 }
                                 whenOutgoingConfiguration { publication ->
                                     publication.configuration {
                                         attributes.attribute(variantAttr, publication.variant.name)
                                     }
                                 }
                                 whenOutgoingSlot { publication ->
                                     def slotName = publication.artifactSlot.slot.name
                                     publication.artifactAttributes {
                                         attribute(slotAttr, slotName)
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_mainJs'
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s5_amdJs'
                                 doLast {
                                     def mainDir = layout.buildDirectory.dir('variant-assemblies/browser/mainJs').get().asFile
                                     def amdDir = layout.buildDirectory.dir('variant-assemblies/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 amdVariant = elements.outgoing.variants.getByName('amdJs')
                                     println('variantAttr=' + elements.attributes.getAttribute(variantAttr))
                                     println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
                                     println('amdSlotAttr=' + amdVariant.attributes.getAttribute(slotAttr))
                                     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("variantAttr=browser"));
                     assertTrue(result.getOutput().contains("primarySlotAttr=mainJs"));
                     assertTrue(result.getOutput().contains("amdSlotAttr=amdJs"));
                     assertTrue(result.getOutput().contains("configurations=browserElements"));
                     assertTrue(result.getOutput().contains("secondaryVariants=amdJs"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
+                void outgoingSlotHookFollowsMaterializedGradleArtifactVariants() throws Exception {
+                    writeSettings("variant-artifacts-materialized-gradle-variant");
+                    writeFile("inputs/typesPackage", "types\n");
+                    writeFile("inputs/js", "js\n");
+                    writeBuildFile("""
+                            import org.gradle.api.attributes.Attribute
+                            apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
+                            def slotAttr = Attribute.of('test.slot', String)
+                            variants.layers.create('main')
+                            variants.roles.create('main')
+                            variants.variant('browser') {
+                                role('main') {
+                                    layers('main')
+                                }
+                            }
+                            variantArtifacts {
+                                variant('browser') {
+                                    primarySlot('typesPackage') {
+                                        from(layout.projectDirectory.file('inputs/typesPackage'))
+                                    }
+                                }
+                                whenOutgoingConfiguration { publication ->
+                                    publication.configuration {
+                                        outgoing.variants.create('js') { secondary ->
+                                            secondary.artifact(layout.projectDirectory.file('inputs/js'))
+                                        }
+                                    }
+                                }
+                                whenOutgoingSlot { publication ->
+                                    publication.artifactAttributes {
+                                        attribute(slotAttr, publication.artifactSlot.slot.name)
+                                    }
+                                }
+                            }
+                            tasks.register('probe') {
+                                doLast {
+                                    def elements = configurations.getByName('browserElements')
+                                    def jsVariant = elements.outgoing.variants.getByName('js')
+                                    println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
+                                    println('jsSlotAttr=' + jsVariant.attributes.getAttribute(slotAttr))
+                                }
+                            }
+                            """);
+                    BuildResult result = runner("probe").build();
+                    assertTrue(result.getOutput().contains("primarySlotAttr=typesPackage"));
+                    assertTrue(result.getOutput().contains("jsSlotAttr=js"));
+                    assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
+                }
+                @Test
                 void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
                     writeSettings("variant-artifacts-single-slot");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 declareOutputs('types')
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     variantArtifacts.whenAvailable { ctx ->
                                         def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
                                         println('primary=' + ctx.findOutgoing(browser).get().primarySlot.get().name)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primary=typesPackage"));
                 }
                 @Test
                 void materializesDirectSlotInputsWithoutVariantSourceBindings() throws Exception {
                     writeSettings("variant-artifacts-direct-input");
                     writeFile("inputs/bundle.js", "console.log('bundle')\n");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('bundle') {
                                         from(layout.projectDirectory.file('inputs/bundle.js'))
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
                                 doLast {
                                     def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
                                     assert new File(bundleDir, 'bundle.js').exists()
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void combinesDirectAndTopologyAwareSlotInputs() throws Exception {
                     writeSettings("variant-artifacts-combined-inputs");
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/marker.txt", "marker\n");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 declareOutputs('js')
                                 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 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
                                 doLast {
                                     def bundleDir = layout.buildDirectory.dir('variant-assemblies/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 {
                     writeSettings("variant-artifacts-missing-variant");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variantArtifacts {
                                 variant('browser') {
                                     slot('mainJs') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownRoleReference() throws Exception {
                     writeSettings("variant-artifacts-missing-role");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('mainJs') {
                                         fromRole('test') {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Role projection for variant 'browser' and role 'test' not found", "help");
                 }
                 @Test
                 void failsWhenPrimarySlotIsMissingForMultipleSlots() throws Exception {
                     writeSettings("variant-artifacts-missing-primary");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 declareOutputs('types', 'js')
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                     slot('js') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     variantArtifacts.whenAvailable { ctx ->
                                         def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
                                         ctx.findOutgoing(browser).get().primarySlot.get()
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Multiple slots declared for browser, please specify primary slot explicitly", "probe");
                 }
                 @Test
                 void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
                     writeSettings("variant-artifacts-layer-outside-topology");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('mainBase')
                             variants.layers.create('extra')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('mainBase')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('extraJs') {
                                         fromLayer('extra') {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Compile unit for variant 'browser' and layer 'extra' not found", "help");
                 }
                 @Test
                 void preservesPrimaryResolutionAndAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'variant-artifacts-resolution'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/types.d.ts", "export type Foo = string\n");
                     writeFile("producer/inputs/index.js", "export const foo = 'bar'\n");
                     writeBuildFile("""
                             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.VariantArtifactsPlugin
                             }
                             project(':producer') {
                                 variants.layers.create('main')
                                 variants.roles.create('main')
                                 variants.variant('browser') {
                                     role('main') {
                                         layers('main')
                                     }
                                 }
                                 variantSources.layer('main') {
                                     declareOutputs('types', 'js')
                                     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')
                                             }
                                         }
                                     }
                                     whenOutgoingConfiguration { publication ->
                                         publication.configuration {
                                             attributes.attribute(variantAttr, publication.variant.name)
                                         }
                                     }
                                     whenOutgoingSlot { publication ->
                                         publication.artifactAttributes {
                                             attribute(slotAttr, publication.artifactSlot.slot.name)
                                         }
                                     }
                                 }
                             }
                             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)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
                     assertTrue(result.getOutput().contains("jsFiles=js"));
                 }
             }

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