implab/gradle-common Commit - r34:5ec65d9e5a34

Refactor variantArtifacts to variant-level publications with primary and secondary slots

cin -

r34:5ec65d9e5a34 default

parent child

Context file:

r34:5ec65d9e5a34

Collapse all files

common/src/main/java/org/implab/gradle/common/sources/OutgoingArtifactSlotPublication.java created 644 +66 0

@@ -0,0 +1,66
	1	package org.implab.gradle.common.sources;
	2
	3	import org.eclipse.jdt.annotation.NonNullByDefault;
	4	import org.gradle.api.Action;
	5	import org.gradle.api.attributes.AttributeContainer;
	6	import org.gradle.api.attributes.HasConfigurableAttributes;
	7	import org.implab.gradle.common.core.lang.Closures;
	8
	9	import groovy.lang.Closure;
	10	import groovy.lang.DelegatesTo;
	11
	12	@NonNullByDefault
	13	public final class OutgoingArtifactSlotPublication {
	14	private final String slotName;
	15	private final boolean primary;
	16	private final VariantArtifactSlot slot;
	17	private final ArtifactAssembly assembly;
	18	private final HasConfigurableAttributes<?> attributesCarrier;
	19
	20	OutgoingArtifactSlotPublication(
	21	String slotName,
	22	boolean primary,
	23	VariantArtifactSlot slot,
	24	ArtifactAssembly assembly,
	25	HasConfigurableAttributes<?> attributesCarrier) {
	26	this.slotName = slotName;
	27	this.primary = primary;
	28	this.slot = slot;
	29	this.assembly = assembly;
	30	this.attributesCarrier = attributesCarrier;
	31	}
	32
	33	public String slotName() {
	34	return slotName;
	35	}
	36
	37	public boolean primary() {
	38	return primary;
	39	}
	40
	41	public VariantArtifactSlot slot() {
	42	return slot;
	43	}
	44
	45	public ArtifactAssembly assembly() {
	46	return assembly;
	47	}
	48
	49	public void configureAssembly(Action<? super ArtifactAssembly> action) {
	50	action.execute(assembly);
	51	}
	52
	53	public void configureAssembly(
	54	@DelegatesTo(value = ArtifactAssembly.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	55	configureAssembly(Closures.action(action));
	56	}
	57
	58	public void configureArtifactAttributes(Action<? super AttributeContainer> action) {
	59	attributesCarrier.attributes(action);
	60	}
	61
	62	public void configureArtifactAttributes(
	63	@DelegatesTo(value = AttributeContainer.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	64	configureArtifactAttributes(Closures.action(action));
	65	}
	66	}

common/variant-artifacts-plugin.md created 644 +311 0

@@ -0,0 +1,311
	1	# Variant Artifacts Plugin
	2
	3	## NAME
	4
	5	`VariantsArtifactsPlugin` и extension `variantArtifacts`.
	6
	7	## SYNOPSIS
	8
	9	```groovy
	10	import org.gradle.api.attributes.Attribute
	11
	12	plugins {
	13	id 'org.implab.gradle-variants-artifacts'
	14	}
	15
	16	def variantAttr = Attribute.of('test.variant', String)
	17	def slotAttr = Attribute.of('test.slot', String)
	18
	19	variants {
	20	layer('main')
	21
	22	variant('browser') {
	23	role('main') { layers('main') }
	24	}
	25	}
	26
	27	variantSources {
	28	bind('main') {
	29	configureSourceSet {
	30	declareOutputs('types', 'js', 'resources')
	31	}
	32	}
	33	}
	34
	35	variantArtifacts {
	36	variant('browser') {
	37	primarySlot('typesPackage') {
	38	fromVariant {
	39	output('types')
	40	}
	41	}
	42
	43	slot('js') {
	44	fromVariant {
	45	output('js')
	46	}
	47	}
	48
	49	slot('resources') {
	50	fromVariant {
	51	output('resources')
	52	}
	53	}
	54	}
	55
	56	whenOutgoingVariant { publication ->
	57	publication.configureConfiguration {
	58	attributes.attribute(variantAttr, publication.variantName())
	59	}
	60
	61	publication.primarySlot().configureArtifactAttributes {
	62	attribute(slotAttr, publication.primarySlot().slotName())
	63	}
	64
	65	publication.requireSlot('js').configureArtifactAttributes {
	66	attribute(slotAttr, 'js')
	67	}
	68
	69	publication.requireSlot('resources').configureArtifactAttributes {
	70	attribute(slotAttr, 'resources')
	71	}
	72	}
	73	}
	74	```
	75
	76	## DESCRIPTION
	77
	78	`VariantsArtifactsPlugin` применяет `VariantsSourcesPlugin`, затем строит
	79	outgoing publication model поверх `variantSources`.
	80
	81	### publication model
	82
	83	Для каждого `variantArtifacts.variant('<name>')` публикуется один outgoing
	84	build variant:
	85
	86	- primary configuration `<variant>Elements`;
	87	- primary artifact slot на самой configuration;
	88	- secondary variants внутри `configuration.outgoing.variants` для остальных slots.
	89
	90	Пример:
	91
	92	- `browserElements`
	93	- primary slot: `typesPackage`
	94	- secondary variants: `js`, `resources`
	95
	96	Это разделяет:
	97
	98	- graph selection build variant-а;
	99	- artifact selection внутри уже выбранного variant-а.
	100
	101	### slot bindings
	102
	103	`slot('<name>')` описывает, какие outputs из `variantSources` войдут в artifact
	104	representation этого slot-а.
	105
	106	Binding rules:
	107
	108	- `fromVariant { output(...) }`
	109	- `fromRole('<role>') { output(...) }`
	110	- `fromLayer('<layer>') { output(...) }`
	111
	112	Каждый slot materialize-ится в отдельный `ArtifactAssembly`:
	113
	114	- task: `process<Variant><Slot>`;
	115	- output dir: `build/variant-artifacts/<variant>/<slot>`.
	116
	117	### primary slot
	118
	119	Primary slot задает artifact, который публикуется как основной artifact
	120	configuration `<variant>Elements`.
	121
	122	Формы DSL:
	123
	124	```groovy
	125	variant('browser') {
	126	primarySlot('typesPackage')
	127
	128	slot('typesPackage') {
	129	fromVariant { output('types') }
	130	}
	131	}
	132	```
	133
	134	или sugar:
	135
	136	```groovy
	137	variant('browser') {
	138	primarySlot('typesPackage') {
	139	fromVariant { output('types') }
	140	}
	141	}
	142	```
	143
	144	Правила:
	145
	146	- если slot один, он считается primary неявно;
	147	- если slots несколько, `primarySlot(...)` обязателен;
	148	- `primarySlot` должен ссылаться на существующий slot.
	149
	150	## LIFECYCLE
	151
	152	- `VariantsArtifactsPlugin` ждет `variants.whenFinalized(...)`;
	153	- после этого валидирует `variantArtifacts`;
	154	- регистрирует `ArtifactAssembly` по каждому slot;
	155	- materialize-ит outgoing publications;
	156	- вызывает `whenOutgoingVariant(...)`;
	157	- callbacks replayable.
	158
	159	После finalize мутации `variantArtifacts` запрещены.
	160
	161	## EVENTS
	162
	163	### whenOutgoingVariant
	164
	165	Replayable callback на готовую outgoing publication variant-а.
	166
	167	Подходит для:
	168
	169	- настройки общих attributes build variant-а один раз;
	170	- настройки per-slot artifact attributes;
	171	- доконфигурации `ArtifactAssembly`.
	172
	173	## PAYLOAD TYPES
	174
	175	### OutgoingVariantPublication
	176
	177	Содержит:
	178
	179	- `variantName()`;
	180	- `topologyVariant()`;
	181	- `variantArtifact()`;
	182	- `configuration()` — primary `<variant>Elements`;
	183	- `primarySlot()`;
	184	- `slots()` — все slot publications;
	185	- `secondarySlots()`;
	186	- `findSlot(name)`, `requireSlot(name)`.
	187
	188	Sugar:
	189
	190	- `configureConfiguration(Action\|Closure)`.
	191
	192	### OutgoingArtifactSlotPublication
	193
	194	Содержит:
	195
	196	- `slotName()`;
	197	- `primary()`;
	198	- `slot()` — модель `VariantArtifactSlot`;
	199	- `assembly()`.
	200
	201	Sugar:
	202
	203	- `configureAssembly(Action\|Closure)`;
	204	- `configureArtifactAttributes(Action\|Closure)`.
	205
	206	`configureArtifactAttributes(...)` пишет attributes:
	207
	208	- в `Configuration.attributes` для primary slot;
	209	- в `ConfigurationVariant.attributes` для secondary slot.
	210
	211	## CONSUMER SIDE
	212
	213	### primary resolution
	214
	215	Обычное inter-project resolution выбирает primary artifact `<variant>Elements`.
	216
	217	Пример:
	218
	219	```groovy
	220	configurations {
	221	compileView {
	222	canBeResolved = true
	223	canBeConsumed = false
	224	canBeDeclared = true
	225	attributes {
	226	attribute(variantAttr, 'browser')
	227	attribute(slotAttr, 'typesPackage')
	228	}
	229	}
	230	}
	231
	232	dependencies {
	233	compileView project(':producer')
	234	}
	235	```
	236
	237	### artifact selection for secondary slots
	238
	239	Secondary artifacts выбираются через `artifactView`.
	240
	241	```groovy
	242	def jsFiles = configurations.compileView.incoming.artifactView {
	243	attributes {
	244	attribute(slotAttr, 'js')
	245	}
	246	}.files
	247	```
	248
	249	Здесь graph variant уже выбран, а `artifactView` выбирает нужный secondary
	250	artifact representation.
	251
	252	## VALIDATION
	253
	254	Проверяется:
	255
	256	- variant существует в topology model;
	257	- slot bindings не ссылаются на неизвестные role/layer;
	258	- при нескольких slots указан `primarySlot`;
	259	- `primarySlot` ссылается на существующий slot.
	260
	261	## API
	262
	263	### VariantArtifactsExtension
	264
	265	- `variant(String)` — получить/создать variant artifact model;
	266	- `variant(String, Action\|Closure)` — сконфигурировать variant artifact;
	267	- `getVariants()` — контейнер variant artifacts;
	268	- `findVariant(name)`, `requireVariant(name)`;
	269	- `whenOutgoingVariant(...)`.
	270
	271	### VariantArtifact
	272
	273	- `slot(String)` — получить/создать slot;
	274	- `slot(String, Action\|Closure)` — сконфигурировать slot;
	275	- `primarySlot(String)` — назначить primary slot;
	276	- `primarySlot(String, Action\|Closure)` — sugar: configure slot + mark as primary;
	277	- `getSlots()`;
	278	- `findSlot(name)`, `requireSlot(name)`;
	279	- `findPrimarySlotName()`, `requirePrimarySlotName()`;
	280	- `findPrimarySlot()`, `requirePrimarySlot()`.
	281
	282	### VariantArtifactSlot
	283
	284	- `fromVariant(...)`;
	285	- `fromRole(String, ...)`;
	286	- `fromLayer(String, ...)`.
	287
	288	### OutputSelectionSpec
	289
	290	- `output(name)`;
	291	- `output(name, extra...)`.
	292
	293	## KEY CLASSES
	294
	295	- `VariantsArtifactsPlugin` — plugin adapter и materialization outgoing variants.
	296	- `VariantArtifactsExtension` — root DSL и lifecycle.
	297	- `VariantArtifact` — outgoing build variant model.
	298	- `VariantArtifactSlot` — artifact representation slot.
	299	- `OutgoingVariantPublication` — payload variant-level publication callback.
	300	- `OutgoingArtifactSlotPublication` — payload per-slot publication callback.
	301	- `ArtifactAssembly` — assembled files for a slot.
	302
	303	## NOTES
	304
	305	- `common` не навязывает доменную логику выбора primary slot.
	306	- `common` не фиксирует значения `usage`, `libraryelements` и прочих
	307	slot-specific attributes.
	308	- `common` не смешивает эту модель с отдельными publish осями вроде package
	309	metadata.
	310	- Closure callbacks используют delegate-first; для вложенных closure удобнее
	311	явный параметр (`publication -> ...`, `slotPublication -> ...`).

common/src/main/java/org/implab/gradle/common/sources/OutgoingVariantPublication.java +70 -19

@@ -1,38 +1,89
1	package org.implab.gradle.common.sources;	1	package org.implab.gradle.common.sources;
2		2
3	import org.eclipse.jdt.annotation.NonNullByDefault;	3	import org.eclipse.jdt.annotation.NonNullByDefault;
4	import org.implab.gradle.common.core.lang.Closures;	4	import org.implab.gradle.common.core.lang.Closures;
5	import org.gradle.api.Action;	5	import org.gradle.api.Action;
6	import org.gradle.api.NamedDomainObjectProvider;
7	import org.gradle.api.artifacts.Configuration;	6	import org.gradle.api.artifacts.Configuration;
		7	import org.gradle.api.InvalidUserDataException;
8		8
9	import groovy.lang.Closure;	9	import groovy.lang.Closure;
10	import groovy.lang.DelegatesTo;	10	import groovy.lang.DelegatesTo;
11		11
12	@NonNullByDefault	12	@NonNullByDefault
13	public ~~record~~ OutgoingVariantPublication(	13	public final class OutgoingVariantPublication {
14	String variantName,	14	private final String variantName;
15	String slotName,	15	private final BuildVariant topologyVariant;
16	BuildVariant topologyVariant,	16	private final VariantArtifact variantArtifact;
17	VariantArtifact variantArtifact,	17	private final Configuration configuration;
18	VariantArtifactSlot slot,	18	private final OutgoingArtifactSlotPublication primarySlot;
19	ArtifactAssembly assembly,	19	private final java.util.List<OutgoingArtifactSlotPublication> slots;
20	NamedDomainObjectProvider<? extends Configuration> configuration) {	20
		21	public OutgoingVariantPublication(
		22	String variantName,
		23	BuildVariant topologyVariant,
		24	VariantArtifact variantArtifact,
		25	Configuration configuration,
		26	OutgoingArtifactSlotPublication primarySlot,
		27	java.util.List<OutgoingArtifactSlotPublication> slots) {
		28	this.variantName = variantName;
		29	this.topologyVariant = topologyVariant;
		30	this.variantArtifact = variantArtifact;
		31	this.configuration = configuration;
		32	this.primarySlot = primarySlot;
		33	this.slots = java.util.List.copyOf(slots);
		34	}
		35
		36	public String variantName() {
		37	return variantName;
		38	}
		39
		40	public BuildVariant topologyVariant() {
		41	return topologyVariant;
		42	}
		43
		44	public VariantArtifact variantArtifact() {
		45	return variantArtifact;
		46	}
		47
		48	public Configuration configuration() {
		49	return configuration;
		50	}
		51
		52	public OutgoingArtifactSlotPublication primarySlot() {
		53	return primarySlot;
		54	}
		55
		56	public java.util.List<OutgoingArtifactSlotPublication> slots() {
		57	return slots;
		58	}
		59
		60	public java.util.List<OutgoingArtifactSlotPublication> secondarySlots() {
		61	return slots.stream()
		62	.filter(slotPublication -> !slotPublication.primary())
		63	.toList();
		64	}
		65
		66	public java.util.Optional<OutgoingArtifactSlotPublication> findSlot(String slotName) {
		67	var normalizedSlotName = VariantArtifact.normalize(slotName, "slot name must not be null or blank");
		68	return slots.stream()
		69	.filter(slotPublication -> normalizedSlotName.equals(slotPublication.slotName()))
		70	.findFirst();
		71	}
		72
		73	public OutgoingArtifactSlotPublication requireSlot(String slotName) {
		74	var normalizedSlotName = VariantArtifact.normalize(slotName, "slot name must not be null or blank");
		75	return findSlot(normalizedSlotName)
		76	.orElseThrow(() -> new InvalidUserDataException(
		77	"Outgoing publication for variant '" + variantName + "' doesn't declare slot '"
		78	+ normalizedSlotName + "'"));
		79	}
		80
21	public void configureConfiguration(Action<? super Configuration> action) {	81	public void configureConfiguration(Action<? super Configuration> action) {
22	configuration.configure(action);	82	action.execute(configuration);
23	}	83	}
24		84
25	public void configureConfiguration(	85	public void configureConfiguration(
26	@DelegatesTo(value = Configuration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {	86	@DelegatesTo(value = Configuration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
27	configureConfiguration(Closures.action(action));	87	configureConfiguration(Closures.action(action));
28	}	88	}
29
30	public void configureAssembly(Action<? super ArtifactAssembly> action) {
31	action.execute(assembly);
32	}
33
34	public void configureAssembly(
35	@DelegatesTo(value = ArtifactAssembly.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
36	configureAssembly(Closures.action(action));
37	}
38	}	89	}

common/src/main/java/org/implab/gradle/common/sources/VariantArtifact.java +41 0

             package org.implab.gradle.common.sources;
             import java.util.Optional;
             import javax.inject.Inject;
             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.NamedDomainObjectContainer;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             @NonNullByDefault
             public class VariantArtifact implements Named {
                 private final String name;
                 private final NamedDomainObjectContainer<VariantArtifactSlot> slots;
+                private String primarySlotName;
                 private boolean finalized;
                 @Inject
                 public VariantArtifact(String name, NamedDomainObjectContainer<VariantArtifactSlot> slots) {
                     this.name = normalize(name, "variant artifact name must not be null or blank");
                     this.slots = slots;
                     slots.all(slot -> {
                         if (finalized)
                             throw new InvalidUserDataException(
                                     "Variant artifact '" + this.name + "' is finalized and cannot add slot '" + slot.getName() + "'");
                     });
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 public NamedDomainObjectContainer<VariantArtifactSlot> getSlots() {
                     return slots;
                 }
                 public VariantArtifactSlot slot(String name) {
                     return slot(name, slot -> {
                     });
                 }
                 public VariantArtifactSlot slot(String name, Action<? super VariantArtifactSlot> configure) {
                     ensureMutable("configure slots");
                     var slot = slots.maybeCreate(normalize(name, "slot name must not be null or blank"));
                     configure.execute(slot);
                     return slot;
                 }
                 public VariantArtifactSlot slot(
                         String name,
                         @DelegatesTo(value = VariantArtifactSlot.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return slot(name, Closures.action(configure));
                 }
                 public Optional<VariantArtifactSlot> findSlot(String slotName) {
                     return Optional.ofNullable(slots.findByName(normalize(slotName, "slot name must not be null or blank")));
                 }
+                public void primarySlot(String slotName) {
+                    ensureMutable("configure primary slot");
+                    primarySlotName = normalize(slotName, "primary slot name must not be null or blank");
+                }
+                public VariantArtifactSlot primarySlot(String slotName, Action<? super VariantArtifactSlot> configure) {
+                    ensureMutable("configure primary slot");
+                    var slot = slot(slotName, configure);
+                    primarySlot(slot.getName());
+                    return slot;
+                }
+                public VariantArtifactSlot primarySlot(
+                        String slotName,
+                        @DelegatesTo(value = VariantArtifactSlot.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
+                    return primarySlot(slotName, Closures.action(configure));
+                }
+                public Optional<String> findPrimarySlotName() {
+                    return Optional.ofNullable(primarySlotName)
+                            .or(() -> slots.getNames().size() == 1 ? Optional.of(slots.iterator().next().getName()) : Optional.empty());
+                }
+                public String requirePrimarySlotName() {
+                    return findPrimarySlotName()
+                            .orElseThrow(() -> new InvalidUserDataException(
+                                    "Variant artifact '" + name + "' must declare primary slot because it has multiple slots"));
+                }
+                public Optional<VariantArtifactSlot> findPrimarySlot() {
+                    return findPrimarySlotName().flatMap(this::findSlot);
+                }
+                public VariantArtifactSlot requirePrimarySlot() {
+                    var resolvedPrimarySlotName = requirePrimarySlotName();
+                    return findSlot(resolvedPrimarySlotName)
+                            .orElseThrow(() -> new InvalidUserDataException(
+                                    "Variant artifact '" + name + "' declares unknown primary slot '" + resolvedPrimarySlotName + "'"));
+                }
                 public VariantArtifactSlot requireSlot(String slotName) {
                     var normalizedSlotName = normalize(slotName, "slot name must not be null or blank");
                     return Optional.ofNullable(slots.findByName(normalizedSlotName))
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant artifact '" + name + "' doesn't declare slot '" + normalizedSlotName + "'"));
                 }
                 void finalizeModel() {
                     if (finalized)
                         return;
                     for (var slot : slots)
                         slot.finalizeModel();
                     finalized = true;
                 }
                 static String normalize(String value, String message) {
                     return Optional.ofNullable(value)
                             .map(String::trim)
                             .filter(trimmed -> !trimmed.isEmpty())
                             .orElseThrow(() -> new InvalidUserDataException(message));
                 }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("Variant artifact '" + name + "' is finalized and cannot " + operation);
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsExtension.java +13 0

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Optional;
             import javax.inject.Inject;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             @NonNullByDefault
             public abstract class VariantArtifactsExtension {
                 private final NamedDomainObjectContainer<VariantArtifact> variants;
                 private final ObjectFactory objects;
                 private final List<Action<? super OutgoingVariantPublication>> outgoingVariantActions = new ArrayList<>();
                 private final List<OutgoingVariantPublication> outgoingVariants = new ArrayList<>();
                 private boolean finalized;
                 @Inject
                 public VariantArtifactsExtension(ObjectFactory objects) {
                     this.objects = objects;
                     variants = objects.domainObjectContainer(VariantArtifact.class, this::newVariantArtifact);
                     variants.all(variant -> {
                         if (finalized)
                             throw new InvalidUserDataException(
                                     "variantArtifacts model is finalized and cannot add variant '" + variant.getName() + "'");
                     });
                 }
                 public NamedDomainObjectContainer<VariantArtifact> getVariants() {
                     return variants;
                 }
                 public VariantArtifact variant(String name) {
                     return variant(name, variant -> {
                     });
                 }
                 public VariantArtifact variant(String name, Action<? super VariantArtifact> configure) {
                     ensureMutable("configure variants");
                     var variant = variants.maybeCreate(VariantArtifact.normalize(name, "variant name must not be null or blank"));
                     configure.execute(variant);
                     return variant;
                 }
                 public VariantArtifact variant(
                         String name,
                         @DelegatesTo(value = VariantArtifact.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return variant(name, Closures.action(configure));
                 }
                 public Optional<VariantArtifact> findVariant(String variantName) {
                     return Optional
                             .ofNullable(variants.findByName(VariantArtifact.normalize(variantName, "variant name must not be null or blank")));
                 }
                 public VariantArtifact requireVariant(String variantName) {
                     var normalizedVariantName = VariantArtifact.normalize(variantName, "variant name must not be null or blank");
                     return findVariant(normalizedVariantName)
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant artifacts do not declare variant '" + normalizedVariantName + "'"));
                 }
                 public void whenOutgoingVariant(Action<? super OutgoingVariantPublication> action) {
                     outgoingVariantActions.add(action);
                     for (var publication : outgoingVariants)
                         action.execute(publication);
                 }
                 public void whenOutgoingVariant(
                         @DelegatesTo(value = OutgoingVariantPublication.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenOutgoingVariant(Closures.action(action));
                 }
                 public boolean isFinalized() {
                     return finalized;
                 }
                 void finalizeModel(BuildVariantsExtension topology) {
                     if (finalized)
                         return;
                     validate(topology);
                     for (var variant : variants)
                         variant.finalizeModel();
                     finalized = true;
                 }
                 void notifyOutgoingVariant(OutgoingVariantPublication publication) {
                     outgoingVariants.add(publication);
                     for (var action : outgoingVariantActions)
                         action.execute(publication);
                 }
                 private VariantArtifact newVariantArtifact(String name) {
                     return objects.newInstance(VariantArtifact.class, name, objects.domainObjectContainer(VariantArtifactSlot.class));
                 }
                 private void validate(BuildVariantsExtension topology) {
                     var errors = new ArrayList<String>();
                     for (var variantArtifact : variants) {
                         var topologyVariant = topology.find(variantArtifact.getName());
                         if (topologyVariant.isEmpty()) {
                             errors.add("Variant artifact '" + variantArtifact.getName() + "' references unknown variant '"
                                     + variantArtifact.getName() + "'");
                             continue;
                         }
                         validateVariantArtifact(variantArtifact, topologyVariant.get(), errors);
                     }
                     if (!errors.isEmpty()) {
                         var message = new StringBuilder("Invalid variantArtifacts model:");
                         for (var error : errors)
                             message.append("\n - ").append(error);
                         throw new InvalidUserDataException(message.toString());
                     }
                 }
                 private static void validateVariantArtifact(VariantArtifact variantArtifact, BuildVariant topologyVariant, List<String> errors) {
                     var roleNames = new LinkedHashSet<String>();
                     var layerNames = new LinkedHashSet<String>();
                     for (var role : topologyVariant.getRoles()) {
                         roleNames.add(role.getName());
                         layerNames.addAll(role.getLayers().getOrElse(List.of()));
                     }
+                    if (!variantArtifact.getSlots().isEmpty()) {
+                        if (variantArtifact.findPrimarySlotName().isEmpty()) {
+                            errors.add("Variant artifact '" + variantArtifact.getName()
+                                    + "' must declare primary slot because it has multiple slots");
+                        } else {
+                            var primarySlotName = variantArtifact.requirePrimarySlotName();
+                            if (variantArtifact.findSlot(primarySlotName).isEmpty()) {
+                                errors.add("Variant artifact '" + variantArtifact.getName()
+                                        + "' declares unknown primary slot '" + primarySlotName + "'");
+                            }
+                        }
+                    }
                     for (var slot : variantArtifact.getSlots()) {
                         for (var rule : slot.bindingRules()) {
                             switch (rule.selector().kind()) {
                                 case VARIANT -> {
                                 }
                                 case ROLE -> {
                                     if (!roleNames.contains(rule.selector().value())) {
                                         errors.add("Variant artifact '" + variantArtifact.getName() + "', slot '" + slot.getName()
                                                 + "' references unknown role '" + rule.selector().value() + "'");
                                     }
                                 }
                                 case LAYER -> {
                                     if (!layerNames.contains(rule.selector().value())) {
                                         errors.add("Variant artifact '" + variantArtifact.getName() + "', slot '" + slot.getName()
                                                 + "' references unknown layer '" + rule.selector().value() + "'");
                                     }
                                 }
                             }
                         }
                     }
                 }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("variantArtifacts model is finalized and cannot " + operation);
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantsArtifactsPlugin.java +112 -28

@@ -1,96 +1,180
1	package org.implab.gradle.common.sources;	1	package org.implab.gradle.common.sources;
2		2
		3	import java.util.LinkedHashMap;
		4	import java.util.List;
		5	import java.util.ArrayList;
		6	import java.util.stream.Collectors;
		7	import java.util.stream.Stream;
		8
3	import org.gradle.api.GradleException;	9	import org.gradle.api.GradleException;
4	import org.gradle.api.Plugin;	10	import org.gradle.api.Plugin;
5	import org.gradle.api.Project;	11	import org.gradle.api.Project;
6	import org.gradle.api.artifacts.Configuration;	12	import org.gradle.api.artifacts.Configuration;
		13	import org.gradle.api.artifacts.ConfigurationPublications;
		14	import org.gradle.api.artifacts.ConfigurationVariant;
7	import org.gradle.api.logging.Logger;	15	import org.gradle.api.logging.Logger;
8	import org.gradle.api.logging.Logging;	16	import org.gradle.api.logging.Logging;
9	import org.implab.gradle.common.core.lang.Strings;	17	import org.implab.gradle.common.core.lang.Strings;
10		18
11	public abstract class VariantsArtifactsPlugin implements Plugin<Project> {	19	public abstract class VariantsArtifactsPlugin implements Plugin<Project> {
12	private static final Logger logger = Logging.getLogger(VariantsArtifactsPlugin.class);	20	private static final Logger logger = Logging.getLogger(VariantsArtifactsPlugin.class);
13	public static final String VARIANT_ARTIFACTS_EXTENSION_NAME = "variantArtifacts";	21	public static final String VARIANT_ARTIFACTS_EXTENSION_NAME = "variantArtifacts";
14		22
15	@Override	23	@Override
16	public void apply(Project target) {	24	public void apply(Project target) {
17	logger.debug("Registering '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());	25	logger.debug("Registering '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
18		26
19	target.getPluginManager().apply(VariantsSourcesPlugin.class);	27	target.getPluginManager().apply(VariantsSourcesPlugin.class);
20		28
21	var variants = VariantsPlugin.getVariantsExtension(target);	29	var variants = VariantsPlugin.getVariantsExtension(target);
22	var variantSources = target.getExtensions().getByType(VariantSourcesExtension.class);	30	var variantSources = target.getExtensions().getByType(VariantSourcesExtension.class);
23	var variantArtifacts = target.getExtensions()	31	var variantArtifacts = target.getExtensions()
24	.create(VARIANT_ARTIFACTS_EXTENSION_NAME, VariantArtifactsExtension.class);	32	.create(VARIANT_ARTIFACTS_EXTENSION_NAME, VariantArtifactsExtension.class);
25	var variantArtifactsResolver = new VariantArtifactsResolver(target.getObjects());	33	var variantArtifactsResolver = new VariantArtifactsResolver(target.getObjects());
26	var artifactAssemblies = new ArtifactAssemblyRegistry(target.getObjects(), target.getTasks());	34	var artifactAssemblies = new ArtifactAssemblyRegistry(target.getObjects(), target.getTasks());
27		35
28	variantSources.whenBound(variantArtifactsResolver::recordBinding);	36	variantSources.whenBound(variantArtifactsResolver::recordBinding);
29		37
30	variants.whenFinalized(model -> {	38	variants.whenFinalized(model -> {
31	logger.debug("Finalizing variantArtifacts model on project '{}'", target.getPath());	39	logger.debug("Finalizing variantArtifacts model on project '{}'", target.getPath());
32	variantArtifacts.finalizeModel(model);	40	variantArtifacts.finalizeModel(model);
33	materializeOutgoingVariants(target, model, variantArtifacts, variantArtifactsResolver, artifactAssemblies);	41	materializeOutgoingVariants(target, model, variantArtifacts, variantArtifactsResolver, artifactAssemblies);
34	logger.debug("variantArtifacts model finalized on project '{}'", target.getPath());	42	logger.debug("variantArtifacts model finalized on project '{}'", target.getPath());
35	});	43	});
36	}	44	}
37		45
38	public static VariantArtifactsExtension getVariantArtifactsExtension(Project target) {	46	public static VariantArtifactsExtension getVariantArtifactsExtension(Project target) {
39	var extension = target.getExtensions().findByType(VariantArtifactsExtension.class);	47	var extension = target.getExtensions().findByType(VariantArtifactsExtension.class);
40		48
41	if (extension == null) {	49	if (extension == null) {
42	logger.error("variantArtifacts extension '{}' isn't found on project '{}'",	50	logger.error("variantArtifacts extension '{}' isn't found on project '{}'",
43	VARIANT_ARTIFACTS_EXTENSION_NAME,	51	VARIANT_ARTIFACTS_EXTENSION_NAME,
44	target.getPath());	52	target.getPath());
45	throw new GradleException("variantArtifacts extension isn't found");	53	throw new GradleException("variantArtifacts extension isn't found");
46	}	54	}
47		55
48	logger.debug("Resolved '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());	56	logger.debug("Resolved '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
49		57
50	return extension;	58	return extension;
51	}	59	}
52		60
53	private static void materializeOutgoingVariants(	61	private static void materializeOutgoingVariants(
54	Project project,	62	Project project,
55	BuildVariantsExtension topology,	63	BuildVariantsExtension topology,
56	VariantArtifactsExtension variantArtifacts,	64	VariantArtifactsExtension variantArtifacts,
57	VariantArtifactsResolver variantArtifactsResolver,	65	VariantArtifactsResolver variantArtifactsResolver,
58	ArtifactAssemblyRegistry artifactAssemblies) {	66	ArtifactAssemblyRegistry artifactAssemblies) {
59	~~for~~ (~~var~~ ~~variantArtifact~~ : variantArtifacts.getVariants()) {	67	variantArtifacts.getVariants().stream()
60	var topologyVariant = topology.require(variantArtifact.getName());	68	.filter(variantArtifact -> !variantArtifact.getSlots().isEmpty())
61	for (var slot : variantArtifact.getSlots()) {	69	.forEach(variantArtifact -> materializeOutgoingVariant(
62	var assembly = artifactAssemblies.register(	70	project,
63	variantArtifact.~~getName~~() + ~~Strings~~.~~capitalize~~(~~slot~~.getName()),	71	topology.require(variantArtifact.getName()),
64	"process" + Strings.capitalize(variantArtifact.getName()) + Strings.capitalize(slot.getName()),
65	project.getLayout().getBuildDirectory()
66	.dir("variant-artifacts/" + variantArtifact.getName() + "/" + slot.getName()),
67	files -> files.from(variantArtifactsResolver.files(variantArtifact.getName(), slot)));
68	var configuration = createOutgoingConfiguration(project, variantArtifact.getName(), slot.getName(), assembly);
69
70	variantArtifacts.notifyOutgoingVariant(new OutgoingVariantPublication(
71	variantArtifact.getName(),
72	slot.getName(),
73	topologyVariant,
74	variantArtifact,	72	variantArtifact,
75	~~slot~~,	73	variantArtifactsResolver,
76	assembly,	74	artifactAssemblies,
77	~~configuration~~));	75	variantArtifacts));
78	}
79	}
80	}	76	}
81		77
82	private static org.gradle.api.NamedDomainObjectProvider<? extends Configuration> createOutgoingConfiguration(	78	private static void materializeOutgoingVariant(
		79	Project project,
		80	BuildVariant topologyVariant,
		81	VariantArtifact variantArtifact,
		82	VariantArtifactsResolver variantArtifactsResolver,
		83	ArtifactAssemblyRegistry artifactAssemblies,
		84	VariantArtifactsExtension variantArtifacts) {
		85	var assemblies = variantArtifact.getSlots().stream()
		86	.collect(Collectors.toMap(
		87	VariantArtifactSlot::getName,
		88	slot -> registerAssembly(project, variantArtifactsResolver, artifactAssemblies, variantArtifact, slot),
		89	(left, right) -> left,
		90	LinkedHashMap::new));
		91
		92	var primarySlot = variantArtifact.requirePrimarySlot();
		93	var configuration = createOutgoingConfiguration(project, variantArtifact.getName(), primarySlot.getName());
		94	var primaryAssembly = assemblies.get(primarySlot.getName());
		95	publishPrimaryArtifact(configuration, primaryAssembly);
		96	var primaryPublication = new OutgoingArtifactSlotPublication(
		97	primarySlot.getName(),
		98	true,
		99	primarySlot,
		100	primaryAssembly,
		101	configuration);
		102	var secondarySlots = variantArtifact.getSlots().stream()
		103	.filter(slot -> !slot.getName().equals(primarySlot.getName()))
		104	.map(slot -> new SecondarySlot(slot, assemblies.get(slot.getName())))
		105	.toList();
		106	var secondaryPublications = new ArrayList<OutgoingArtifactSlotPublication>(secondarySlots.size());
		107	secondarySlots.forEach(secondarySlot -> {
		108	var secondaryVariant = configuration.getOutgoing().getVariants().create(secondarySlot.slot().getName());
		109	publishSecondaryArtifact(secondaryVariant, secondarySlot.assembly());
		110	secondaryPublications.add(new OutgoingArtifactSlotPublication(
		111	secondarySlot.slot().getName(),
		112	false,
		113	secondarySlot.slot(),
		114	secondarySlot.assembly(),
		115	secondaryVariant));
		116	});
		117
		118	var slotPublications = Stream.concat(
		119	Stream.of(primaryPublication),
		120	secondaryPublications.stream())
		121	.toList();
		122
		123	variantArtifacts.notifyOutgoingVariant(new OutgoingVariantPublication(
		124	variantArtifact.getName(),
		125	topologyVariant,
		126	variantArtifact,
		127	configuration,
		128	primaryPublication,
		129	slotPublications));
		130	}
		131
		132	private static ArtifactAssembly registerAssembly(
		133	Project project,
		134	VariantArtifactsResolver variantArtifactsResolver,
		135	ArtifactAssemblyRegistry artifactAssemblies,
		136	VariantArtifact variantArtifact,
		137	VariantArtifactSlot slot) {
		138	return artifactAssemblies.register(
		139	variantArtifact.getName() + Strings.capitalize(slot.getName()),
		140	"process" + Strings.capitalize(variantArtifact.getName()) + Strings.capitalize(slot.getName()),
		141	project.getLayout().getBuildDirectory()
		142	.dir("variant-artifacts/" + variantArtifact.getName() + "/" + slot.getName()),
		143	files -> files.from(variantArtifactsResolver.files(variantArtifact.getName(), slot)));
		144	}
		145
		146	private static Configuration createOutgoingConfiguration(
83	Project project,	147	Project project,
84	String variantName,	148	String variantName,
85	String ~~slotName~~,	149	String primarySlotName) {
86	ArtifactAssembly assembly) {	150	var configName = variantName + "Elements";
87	var configName = variantName + Strings.capitalize(slotName) + "Elements";
88	return project.getConfigurations().consumable(configName, config -> {	151	return project.getConfigurations().consumable(configName, config -> {
89	config.setVisible(true);	152	config.setVisible(true);
90	config.setDescription("Consumable assembled artifacts for variant '" + variantName + ~~"', slot '"~~ + ~~slotName~~ + ~~"'"~~);	153	config.setDescription("Consumable assembled artifacts for variant '" + variantName
91	config.getOutgoing().artifact(assembly.getOutput().getSingleFile(), published -> {	154	+ "' with primary slot '" + primarySlotName + "'");
92	published.builtBy(assembly.getOutput().getBuildDependencies());	155	}).get();
93	});	156	}
		157
		158	private static void publishPrimaryArtifact(Configuration configuration, ArtifactAssembly assembly) {
		159	publishArtifact(configuration.getOutgoing(), assembly);
		160	}
		161
		162	private static void publishSecondaryArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
		163	publishArtifact(variant, assembly);
		164	}
		165
		166	private static void publishArtifact(ConfigurationPublications outgoing, ArtifactAssembly assembly) {
		167	outgoing.artifact(assembly.getOutput().getSingleFile(), published -> {
		168	published.builtBy(assembly.getOutput().getBuildDependencies());
94	});	169	});
95	}	170	}
		171
		172	private static void publishArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
		173	variant.artifact(assembly.getOutput().getSingleFile(), published -> {
		174	published.builtBy(assembly.getOutput().getBuildDependencies());
		175	});
		176	}
		177
		178	private record SecondarySlot(VariantArtifactSlot slot, ArtifactAssembly assembly) {
		179	}
96	}	180	}

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

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

General Comments 0

Write
Preview

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

No TODOs yet

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

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