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

		@@ -3,36 +3,87 package org.implab.gradle.common.sources
3	3	import org.eclipse.jdt.annotation.NonNullByDefault;
4	4	import org.implab.gradle.common.core.lang.Closures;
5	5	import org.gradle.api.Action;
6		import org.gradle.api.NamedDomainObjectProvider;
7	6	import org.gradle.api.artifacts.Configuration;
	7	import org.gradle.api.InvalidUserDataException;
8	8
9	9	import groovy.lang.Closure;
10	10	import groovy.lang.DelegatesTo;
11	11
12	12	@NonNullByDefault
13		public ~~record~~ OutgoingVariantPublication(
14		String variantName,
15		String slotName,
16		BuildVariant topologyVariant,
17		VariantArtifact variantArtifact,
18		VariantArtifactSlot slot,
19		ArtifactAssembly assembly,
20		NamedDomainObjectProvider<? extends Configuration> configuration) {
	13	public final class OutgoingVariantPublication {
	14	private final String variantName;
	15	private final BuildVariant topologyVariant;
	16	private final VariantArtifact variantArtifact;
	17	private final Configuration configuration;
	18	private final OutgoingArtifactSlotPublication primarySlot;
	19	private final java.util.List<OutgoingArtifactSlotPublication> slots;
	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	81	public void configureConfiguration(Action<? super Configuration> action) {
22		configuration.configure(action);
	82	action.execute(configuration);
23	83	}
24	84
25	85	public void configureConfiguration(
26	86	@DelegatesTo(value = Configuration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
27	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

              public class VariantArtifact implements Named {
                  private final String name;
                  private final NamedDomainObjectContainer<VariantArtifactSlot> slots;
+                 private String primarySlotName;
                  private boolean finalized;
                  @Inject
                      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))

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

                          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()) {

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

		@@ -1,9 +1,17
1	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	9	import org.gradle.api.GradleException;
4	10	import org.gradle.api.Plugin;
5	11	import org.gradle.api.Project;
6	12	import org.gradle.api.artifacts.Configuration;
	13	import org.gradle.api.artifacts.ConfigurationPublications;
	14	import org.gradle.api.artifacts.ConfigurationVariant;
7	15	import org.gradle.api.logging.Logger;
8	16	import org.gradle.api.logging.Logging;
9	17	import org.implab.gradle.common.core.lang.Strings;
		@@ -56,41 +64,117 public abstract class VariantsArtifactsP
56	64	VariantArtifactsExtension variantArtifacts,
57	65	VariantArtifactsResolver variantArtifactsResolver,
58	66	ArtifactAssemblyRegistry artifactAssemblies) {
59		~~for~~ (~~var~~ ~~variantArtifact~~ : variantArtifacts.getVariants()) {
60		var topologyVariant = topology.require(variantArtifact.getName());
61		for (var slot : variantArtifact.getSlots()) {
62		var assembly = artifactAssemblies.register(
63		variantArtifact.~~getName~~() + ~~Strings~~.~~capitalize~~(~~slot~~.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,
	67	variantArtifacts.getVariants().stream()
	68	.filter(variantArtifact -> !variantArtifact.getSlots().isEmpty())
	69	.forEach(variantArtifact -> materializeOutgoingVariant(
	70	project,
	71	topology.require(variantArtifact.getName()),
74	72	variantArtifact,
75		~~slot~~,
76		assembly,
77		~~configuration~~));
78		}
79		}
	73	variantArtifactsResolver,
	74	artifactAssemblies,
	75	variantArtifacts));
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	147	Project project,
84	148	String variantName,
85		String ~~slotName~~,
86		ArtifactAssembly assembly) {
87		var configName = variantName + Strings.capitalize(slotName) + "Elements";
	149	String primarySlotName) {
	150	var configName = variantName + "Elements";
88	151	return project.getConfigurations().consumable(configName, config -> {
89	152	config.setVisible(true);
90		config.setDescription("Consumable assembled artifacts for variant '" + variantName + ~~"', slot '"~~ + ~~slotName~~ + ~~"'"~~);
91		config.getOutgoing().artifact(assembly.getOutput().getSingleFile(), published -> {
92		published.builtBy(assembly.getOutput().getBuildDependencies());
93		});
	153	config.setDescription("Consumable assembled artifacts for variant '" + variantName
	154	+ "' with primary slot '" + primarySlotName + "'");
	155	}).get();
	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

		@@ -9,6 +9,7 import java.io.IOException;
9	9	import java.nio.file.Files;
10	10	import java.nio.file.Path;
11	11	import java.util.List;
	12	import java.util.stream.Collectors;
12	13
13	14	import org.gradle.testkit.runner.BuildResult;
14	15	import org.gradle.testkit.runner.GradleRunner;
		@@ -80,7 +81,7 class VariantsArtifactsPluginFunctionalT
80	81
81	82	variantArtifacts {
82	83	variant('browser') {
83		slot('mainJs') {
	84	primarySlot('mainJs') {
84	85	fromRole('main') {
85	86	output('js')
86	87	}
		@@ -94,12 +95,14 class VariantsArtifactsPluginFunctionalT
94	95	}
95	96
96	97	whenOutgoingVariant { publication ->
97		publication.~~configureAssembly {~~
98		sources.from(layout.projectDirectory.file("inputs/${publication.slotName()}.txt"))
99		}
	98	publication.slots().each { slotPublication ->
	99	slotPublication.configureAssembly {
	100	sources.from(layout.projectDirectory.file("inputs/${slotPublication.slotName()}.txt"))
	101	}
100	102
101		publication.configure~~Configuration~~ {
102		~~attributes.~~attribute(Attribute.of('test.slot', String), publication.slotName())
	103	slotPublication.configureArtifactAttributes {
	104	attribute(Attribute.of('test.slot', String), slotPublication.slotName())
	105	}
103	106	}
104	107	}
105	108	}
		@@ -119,23 +122,70 class VariantsArtifactsPluginFunctionalT
119	122	assert new File(amdDir, 'amd.js').exists()
120	123	assert new File(amdDir, 'amdJs.txt').exists()
121	124
122		def ~~mainE~~lements = configurations.getByName('browser~~MainJs~~Elements')
123		def attr = ~~mainE~~lements.attributes.getAttribute(Attribute.of('test.slot', String))
	125	def elements = configurations.getByName('browserElements')
	126	def primaryAttr = elements.attributes.getAttribute(Attribute.of('test.slot', String))
	127	def amdVariant = elements.outgoing.variants.getByName('amdJs')
	128	def amdAttr = amdVariant.attributes.getAttribute(Attribute.of('test.slot', String))
124	129
125		println('mainAttr=' + attr)
126		println('configurations=' + [mainElements.name, configurations.getByName('browserAmdJsElements').name].sort().join(','))
	130	println('primarySlot=' + variantArtifacts.requireVariant('browser').requirePrimarySlotName())
	131	println('primaryAttr=' + primaryAttr)
	132	println('amdAttr=' + amdAttr)
	133	println('configurations=' + configurations.matching { it.name == 'browserElements' }.collect { it.name }.join(','))
	134	println('secondaryVariants=' + elements.outgoing.variants.collect { it.name }.sort().join(','))
127	135	}
128	136	}
129	137	""");
130	138
131	139	BuildResult result = runner("probe").build();
132	140
133		assertTrue(result.getOutput().contains("~~mainAttr~~=mainJs"));
134		assertTrue(result.getOutput().contains("~~configurations=browserAmdJsElements,browserMainJsElement~~s"));
	141	assertTrue(result.getOutput().contains("primarySlot=mainJs"));
	142	assertTrue(result.getOutput().contains("primaryAttr=mainJs"));
	143	assertTrue(result.getOutput().contains("amdAttr=amdJs"));
	144	assertTrue(result.getOutput().contains("configurations=browserElements"));
	145	assertTrue(result.getOutput().contains("secondaryVariants=amdJs"));
135	146	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
136	147	}
137	148
138	149	@Test
	150	void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
	151	writeFile(SETTINGS_FILE, ROOT_NAME);
	152	writeFile(BUILD_FILE, """
	153	plugins {
	154	id 'org.implab.gradle-variants-artifacts'
	155	}
	156
	157	variants {
	158	layer('main')
	159
	160	variant('browser') {
	161	role('main') {
	162	layers('main')
	163	}
	164	}
	165	}
	166
	167	variantArtifacts {
	168	variant('browser') {
	169	slot('typesPackage') {
	170	fromVariant {
	171	output('types')
	172	}
	173	}
	174	}
	175	}
	176
	177	tasks.register('probe') {
	178	doLast {
	179	println('primary=' + variantArtifacts.requireVariant('browser').requirePrimarySlotName())
	180	}
	181	}
	182	""");
	183
	184	BuildResult result = runner("probe").build();
	185	assertTrue(result.getOutput().contains("primary=typesPackage"));
	186	}
	187
	188	@Test
139	189	void failsOnUnknownVariantReference() throws Exception {
140	190	assertBuildFails("""
141	191	plugins {
		@@ -188,6 +238,41 class VariantsArtifactsPluginFunctionalT
188	238	}
189	239
190	240	@Test
	241	void failsWhenPrimarySlotIsMissingForMultipleSlots() throws Exception {
	242	assertBuildFails("""
	243	plugins {
	244	id 'org.implab.gradle-variants-artifacts'
	245	}
	246
	247	variants {
	248	layer('main')
	249
	250	variant('browser') {
	251	role('main') {
	252	layers('main')
	253	}
	254	}
	255	}
	256
	257	variantArtifacts {
	258	variant('browser') {
	259	slot('typesPackage') {
	260	fromVariant {
	261	output('types')
	262	}
	263	}
	264
	265	slot('js') {
	266	fromVariant {
	267	output('js')
	268	}
	269	}
	270	}
	271	}
	272	""", "Variant artifact 'browser' must declare primary slot because it has multiple slots");
	273	}
	274
	275	@Test
191	276	void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
192	277	assertBuildFails("""
193	278	plugins {
		@@ -246,6 +331,130 class VariantsArtifactsPluginFunctionalT
246	331	""", "variantArtifacts model is finalized and cannot configure variants");
247	332	}
248	333
	334	@Test
	335	void preservesPrimaryResolutionAndAllowsSecondaryArtifactSelection() throws Exception {
	336	writeFile(SETTINGS_FILE, """
	337	rootProject.name = 'variants-artifacts-fixture'
	338	include 'producer', 'consumer'
	339	""");
	340	writeFile("producer/inputs/types.d.ts", "export type Foo = string\n");
	341	writeFile("producer/inputs/index.js", "export const foo = 'bar'\n");
	342	var buildscriptClasspath = pluginClasspath().stream()
	343	.map(File::getAbsolutePath)
	344	.map(path -> "'" + path.replace("\\", "\\\\") + "'")
	345	.collect(Collectors.joining(", "));
	346	writeFile(BUILD_FILE, """
	347	buildscript {
	348	dependencies {
	349	classpath files(%s)
	350	}
	351	}
	352
	353	import org.gradle.api.attributes.Attribute
	354
	355	def variantAttr = Attribute.of('test.variant', String)
	356	def slotAttr = Attribute.of('test.slot', String)
	357
	358	subprojects {
	359	apply plugin: 'org.implab.gradle-variants-artifacts'
	360	}
	361
	362	project(':producer') {
	363	variants {
	364	layer('main')
	365
	366	variant('browser') {
	367	role('main') {
	368	layers('main')
	369	}
	370	}
	371	}
	372
	373	variantSources {
	374	bind('main') {
	375	configureSourceSet {
	376	declareOutputs('types', 'js')
	377	}
	378	}
	379
	380	whenBound { ctx ->
	381	ctx.configureSourceSet {
	382	registerOutput('types', layout.projectDirectory.file('inputs/types.d.ts'))
	383	registerOutput('js', layout.projectDirectory.file('inputs/index.js'))
	384	}
	385	}
	386	}
	387
	388	variantArtifacts {
	389	variant('browser') {
	390	primarySlot('typesPackage') {
	391	fromVariant {
	392	output('types')
	393	}
	394	}
	395
	396	slot('js') {
	397	fromVariant {
	398	output('js')
	399	}
	400	}
	401	}
	402
	403	whenOutgoingVariant { publication ->
	404	publication.configureConfiguration {
	405	attributes.attribute(variantAttr, publication.variantName())
	406	}
	407
	408	publication.primarySlot().configureArtifactAttributes {
	409	attribute(slotAttr, publication.primarySlot().slotName())
	410	}
	411
	412	publication.requireSlot('js').configureArtifactAttributes {
	413	attribute(slotAttr, 'js')
	414	}
	415	}
	416	}
	417	}
	418
	419	project(':consumer') {
	420	configurations {
	421	compileView {
	422	canBeResolved = true
	423	canBeConsumed = false
	424	canBeDeclared = true
	425	attributes {
	426	attribute(variantAttr, 'browser')
	427	attribute(slotAttr, 'typesPackage')
	428	}
	429	}
	430	}
	431
	432	dependencies {
	433	compileView project(':producer')
	434	}
	435
	436	tasks.register('probe') {
	437	doLast {
	438	def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
	439	def jsFiles = configurations.compileView.incoming.artifactView {
	440	attributes {
	441	attribute(slotAttr, 'js')
	442	}
	443	}.files.files.collect { it.name }.sort().join(',')
	444
	445	println('compileFiles=' + compileFiles)
	446	println('jsFiles=' + jsFiles)
	447	}
	448	}
	449	}
	450	""".formatted(buildscriptClasspath));
	451
	452	BuildResult result = runner(":consumer:probe").build();
	453
	454	assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
	455	assertTrue(result.getOutput().contains("jsFiles=js"));
	456	}
	457
249	458	private GradleRunner runner(String... arguments) {
250	459	return GradleRunner.create()
251	460	.withProjectDir(testProjectDir.toFile())

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