implab/gradle-common Commit - r52:3939ecb6e9a4

Refine variant artifacts publication lifecycle- Remove assembly task access from outgoing slot publication spec- Keep whenOutgoingSlot focused on publication attributes only- Decouple materialization policy handler from artifact assemblies- Drop eager afterEvaluate outgoing configuration realization- Add reference coverage for lazy Gradle outgoing variants- Exercise primary and secondary artifact resolution without forced realization- Keep slot body customization in ArtifactAssemblySpec

cin -

r52:3939ecb6e9a4 default

parent child

Context file:

r52:3939ecb6e9a4

Expand all files

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

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

variants/src/main/resources/META-INF/gradle-plugins/org.implab.gradle-sources.properties created 644 +1 0

	@@ -0,0 +1,1
				1	implementation-class=org.implab.gradle.variants.SourcesPlugin

variants/src/test/java/org/implab/gradle/variants/PluginMarkerFunctionalTest.java created 644 +86 0

@@ -0,0 +1,86
	1	package org.implab.gradle.variants;
	2
	3	import static org.junit.jupiter.api.Assertions.assertEquals;
	4	import static org.junit.jupiter.api.Assertions.assertNotNull;
	5	import static org.junit.jupiter.api.Assertions.assertTrue;
	6
	7	import java.io.IOException;
	8	import java.util.Properties;
	9
	10	import org.gradle.testkit.runner.BuildResult;
	11	import org.junit.jupiter.api.Test;
	12
	13	class PluginMarkerFunctionalTest extends AbstractFunctionalTest {
	14
	15	@Test
	16	void pluginMarkersPointToCurrentImplementations() throws Exception {
	17	assertMarker("org.implab.gradle-variants.properties", VariantsPlugin.class);
	18	assertMarker("org.implab.gradle-sources.properties", SourcesPlugin.class);
	19	assertMarker("org.implab.gradle-variants-sources.properties", VariantSourcesPlugin.class);
	20	assertMarker("org.implab.gradle-variants-artifacts.properties", VariantArtifactsPlugin.class);
	21	}
	22
	23	@Test
	24	void pluginIdsApplyCurrentExtensions() throws Exception {
	25	writeSettings("variants-plugin-ids");
	26	writeBuildFile("""
	27	apply plugin: 'org.implab.gradle-variants'
	28	apply plugin: 'org.implab.gradle-sources'
	29	apply plugin: 'org.implab.gradle-variants-sources'
	30	apply plugin: 'org.implab.gradle-variants-artifacts'
	31
	32	tasks.register('probe') {
	33	doLast {
	34	println("variantsExtension=" + (project.extensions.findByName('variants') != null))
	35	println("sourcesExtension=" + (project.extensions.findByName('sources') != null))
	36	println("variantSourcesExtension=" + (project.extensions.findByName('variantSources') != null))
	37	println("variantArtifactsExtension=" + (project.extensions.findByName('variantArtifacts') != null))
	38	}
	39	}
	40	""");
	41
	42	BuildResult result = runner("probe").build();
	43
	44	assertTrue(result.getOutput().contains("variantsExtension=true"));
	45	assertTrue(result.getOutput().contains("sourcesExtension=true"));
	46	assertTrue(result.getOutput().contains("variantSourcesExtension=true"));
	47	assertTrue(result.getOutput().contains("variantArtifactsExtension=true"));
	48	}
	49
	50	@Test
	51	void sourcesPluginSupportsStandaloneSourceSetWorkflow() throws Exception {
	52	writeSettings("sources-plugin-standalone");
	53	writeFile("inputs/main.js", "console.log('main')\n");
	54	writeBuildFile("""
	55	apply plugin: 'org.implab.gradle-sources'
	56
	57	sources.create('main') {
	58	declareOutputs('js')
	59	registerOutput('js', layout.projectDirectory.file('inputs/main.js'))
	60	}
	61
	62	tasks.register('probe') {
	63	doLast {
	64	def main = sources.named('main').get()
	65	println("sourceSet=" + main.name)
	66	println("jsFiles=" + main.output('js').files.collect { it.name }.sort().join(','))
	67	}
	68	}
	69	""");
	70
	71	BuildResult result = runner("probe").build();
	72
	73	assertTrue(result.getOutput().contains("sourceSet=main"));
	74	assertTrue(result.getOutput().contains("jsFiles=main.js"));
	75	}
	76
	77	private static void assertMarker(String markerName, Class<?> implementationClass) throws IOException {
	78	var resourceName = "META-INF/gradle-plugins/" + markerName;
	79	var resource = PluginMarkerFunctionalTest.class.getClassLoader().getResourceAsStream(resourceName);
	80	assertNotNull(resource, "Missing plugin marker " + resourceName);
	81
	82	var properties = new Properties();
	83	properties.load(resource);
	84	assertEquals(implementationClass.getName(), properties.getProperty("implementation-class"));
	85	}
	86	}

variants/src/test/java/org/implab/gradle/variants/VariantArtifactsPluginFunctionalTest.java created 644 +563 0

This diff has been collapsed as it changes many lines, (563 lines changed) Show them Hide them
	@@ -0,0 +1,563
		1	package org.implab.gradle.variants;
		2
		3	import static org.junit.jupiter.api.Assertions.assertTrue;
		4
		5	import org.gradle.testkit.runner.BuildResult;
		6	import org.gradle.testkit.runner.TaskOutcome;
		7	import org.junit.jupiter.api.Test;
		8
		9	class VariantArtifactsPluginFunctionalTest extends AbstractFunctionalTest {
		10
		11	@Test
		12	void gradleReferenceLazyOutgoingConfigurationAllowsSecondaryArtifactSelection() throws Exception {
		13	writeFile("settings.gradle", """
		14	rootProject.name = 'gradle-reference-outgoing-resolution'
		15	include 'producer', 'consumer'
		16	""");
		17	writeFile("producer/inputs/typesPackage", "types\n");
		18	writeFile("producer/inputs/js", "js\n");
		19	writeBuildFile("""
		20	import org.gradle.api.attributes.Attribute
		21
		22	def variantAttr = Attribute.of('test.variant', String)
		23	def slotAttr = Attribute.of('test.slot', String)
		24
		25	project(':producer') {
		26	def browserElements = configurations.consumable('browserElements')
		27
		28	println('reference: registered browserElements provider')
		29
		30	browserElements.configure { configuration ->
		31	println('reference: configuring browserElements')
		32
		33	configuration.attributes.attribute(variantAttr, 'browser')
		34	configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
		35	configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
		36
		37	configuration.outgoing.variants.create('js') { secondary ->
		38	println('reference: creating js outgoing variant')
		39
		40	secondary.attributes.attribute(slotAttr, 'js')
		41	secondary.artifact(layout.projectDirectory.file('inputs/js'))
		42	}
		43	}
		44	}
		45
		46	project(':consumer') {
		47	configurations {
		48	compileView {
		49	canBeResolved = true
		50	canBeConsumed = false
		51	canBeDeclared = true
		52	attributes {
		53	attribute(variantAttr, 'browser')
		54	attribute(slotAttr, 'typesPackage')
		55	}
		56	}
		57	}
		58
		59	dependencies {
		60	compileView project(':producer')
		61	}
		62
		63	tasks.register('probe') {
		64	doLast {
		65	println('reference: resolving primary files')
		66
		67	def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
		68
		69	println('reference: resolving secondary files')
		70
		71	def jsFiles = configurations.compileView.incoming.artifactView {
		72	attributes {
		73	attribute(slotAttr, 'js')
		74	}
		75	}.files.files.collect { it.name }.sort().join(',')
		76
		77	println('compileFiles=' + compileFiles)
		78	println('jsFiles=' + jsFiles)
		79	}
		80	}
		81	}
		82	""");
		83
		84	BuildResult result = runner(":consumer:probe").build();
		85	var output = result.getOutput();
		86	var registered = output.indexOf("reference: registered browserElements provider");
		87	var resolvingPrimary = output.indexOf("reference: resolving primary files");
		88	var configuring = output.indexOf("reference: configuring browserElements");
		89	var creatingSecondary = output.indexOf("reference: creating js outgoing variant");
		90	var resolvingSecondary = output.indexOf("reference: resolving secondary files");
		91
		92	assertTrue(registered >= 0);
		93	assertTrue(resolvingPrimary >= 0);
		94	assertTrue(configuring >= 0);
		95	assertTrue(creatingSecondary >= 0);
		96	assertTrue(resolvingSecondary >= 0);
		97	assertTrue(registered < resolvingPrimary);
		98	assertTrue(resolvingPrimary < configuring);
		99	assertTrue(configuring < creatingSecondary);
		100	assertTrue(creatingSecondary < resolvingSecondary);
		101	assertTrue(output.contains("compileFiles=typesPackage"));
		102	assertTrue(output.contains("jsFiles=js"));
		103	}
		104
		105	@Test
		106	void materializesPrimaryAndSecondarySlotsAndInvokesOutgoingHooks() throws Exception {
		107	writeSettings("variant-artifacts-slots");
		108	writeFile("inputs/base.js", "console.log('base')\n");
		109	writeFile("inputs/amd.js", "console.log('amd')\n");
		110	writeFile("inputs/mainJs.txt", "mainJs marker\n");
		111	writeFile("inputs/amdJs.txt", "amdJs marker\n");
		112	writeBuildFile("""
		113	import org.gradle.api.attributes.Attribute
		114
		115	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		116
		117	def variantAttr = Attribute.of('test.variant', String)
		118	def slotAttr = Attribute.of('test.slot', String)
		119
		120	variants.layers.create('mainBase')
		121	variants.layers.create('mainAmd')
		122	variants.roles.create('main')
		123	variants.roles.create('test')
		124	variants.variant('browser') {
		125	role('main') {
		126	layers('mainBase', 'mainAmd')
		127	}
		128	}
		129
		130	variantSources {
		131	layer('mainBase') {
		132	declareOutputs('js')
		133	registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
		134	}
		135	layer('mainAmd') {
		136	declareOutputs('js')
		137	registerOutput('js', layout.projectDirectory.file('inputs/amd.js'))
		138	}
		139	}
		140
		141	variantArtifacts {
		142	variant('browser') {
		143	primarySlot('mainJs') {
		144	fromRole('main') {
		145	output('js')
		146	}
		147	from(layout.projectDirectory.file('inputs/mainJs.txt'))
		148	}
		149	slot('amdJs') {
		150	fromLayer('mainAmd') {
		151	output('js')
		152	}
		153	from(layout.projectDirectory.file('inputs/amdJs.txt'))
		154	}
		155	}
		156
		157	whenOutgoingConfiguration { publication ->
		158	publication.configuration {
		159	attributes.attribute(variantAttr, publication.variant.name)
		160	}
		161	}
		162
		163	whenOutgoingSlot { publication ->
		164	def slotName = publication.artifactSlot.slot.name
		165	publication.artifactAttributes {
		166	attribute(slotAttr, slotName)
		167	}
		168	}
		169	}
		170
		171	tasks.register('probe') {
		172	dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_mainJs'
		173	dependsOn 'assembleVariantArtifactSlot_v7_browser_s5_amdJs'
		174
		175	doLast {
		176	def mainDir = layout.buildDirectory.dir('variant-assemblies/browser/mainJs').get().asFile
		177	def amdDir = layout.buildDirectory.dir('variant-assemblies/browser/amdJs').get().asFile
		178
		179	assert new File(mainDir, 'base.js').exists()
		180	assert new File(mainDir, 'amd.js').exists()
		181	assert new File(mainDir, 'mainJs.txt').exists()
		182
		183	assert !new File(amdDir, 'base.js').exists()
		184	assert new File(amdDir, 'amd.js').exists()
		185	assert new File(amdDir, 'amdJs.txt').exists()
		186
		187	def elements = configurations.getByName('browserElements')
		188	def amdVariant = elements.outgoing.variants.getByName('amdJs')
		189
		190	println('variantAttr=' + elements.attributes.getAttribute(variantAttr))
		191	println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
		192	println('amdSlotAttr=' + amdVariant.attributes.getAttribute(slotAttr))
		193	println('configurations=' + configurations.matching { it.name == 'browserElements' }.collect { it.name }.join(','))
		194	println('secondaryVariants=' + elements.outgoing.variants.collect { it.name }.sort().join(','))
		195	}
		196	}
		197	""");
		198
		199	BuildResult result = runner("probe").build();
		200
		201	assertTrue(result.getOutput().contains("variantAttr=browser"));
		202	assertTrue(result.getOutput().contains("primarySlotAttr=mainJs"));
		203	assertTrue(result.getOutput().contains("amdSlotAttr=amdJs"));
		204	assertTrue(result.getOutput().contains("configurations=browserElements"));
		205	assertTrue(result.getOutput().contains("secondaryVariants=amdJs"));
		206	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
		207	}
		208
		209	@Test
		210	void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
		211	writeSettings("variant-artifacts-single-slot");
		212	writeBuildFile("""
		213	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		214
		215	variants.layers.create('main')
		216	variants.roles.create('main')
		217	variants.variant('browser') {
		218	role('main') {
		219	layers('main')
		220	}
		221	}
		222
		223	variantSources.layer('main') {
		224	declareOutputs('types')
		225	}
		226
		227	variantArtifacts {
		228	variant('browser') {
		229	slot('typesPackage') {
		230	fromVariant {
		231	output('types')
		232	}
		233	}
		234	}
		235	}
		236
		237	tasks.register('probe') {
		238	doLast {
		239	variantArtifacts.whenAvailable { ctx ->
		240	def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
		241	println('primary=' + ctx.findOutgoing(browser).get().primarySlot.get().name)
		242	}
		243	}
		244	}
		245	""");
		246
		247	BuildResult result = runner("probe").build();
		248
		249	assertTrue(result.getOutput().contains("primary=typesPackage"));
		250	}
		251
		252	@Test
		253	void materializesDirectSlotInputsWithoutVariantSourceBindings() throws Exception {
		254	writeSettings("variant-artifacts-direct-input");
		255	writeFile("inputs/bundle.js", "console.log('bundle')\n");
		256	writeBuildFile("""
		257	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		258
		259	variants.layers.create('main')
		260	variants.roles.create('main')
		261	variants.variant('browser') {
		262	role('main') {
		263	layers('main')
		264	}
		265	}
		266
		267	variantArtifacts {
		268	variant('browser') {
		269	primarySlot('bundle') {
		270	from(layout.projectDirectory.file('inputs/bundle.js'))
		271	}
		272	}
		273	}
		274
		275	tasks.register('probe') {
		276	dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
		277
		278	doLast {
		279	def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
		280	assert new File(bundleDir, 'bundle.js').exists()
		281	}
		282	}
		283	""");
		284
		285	BuildResult result = runner("probe").build();
		286
		287	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
		288	}
		289
		290	@Test
		291	void combinesDirectAndTopologyAwareSlotInputs() throws Exception {
		292	writeSettings("variant-artifacts-combined-inputs");
		293	writeFile("inputs/base.js", "console.log('base')\n");
		294	writeFile("inputs/marker.txt", "marker\n");
		295	writeBuildFile("""
		296	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		297
		298	variants.layers.create('main')
		299	variants.roles.create('main')
		300	variants.variant('browser') {
		301	role('main') {
		302	layers('main')
		303	}
		304	}
		305
		306	variantSources.layer('main') {
		307	declareOutputs('js')
		308	registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
		309	}
		310
		311	variantArtifacts {
		312	variant('browser') {
		313	primarySlot('bundle') {
		314	fromVariant {
		315	output('js')
		316	}
		317	from(layout.projectDirectory.file('inputs/marker.txt'))
		318	}
		319	}
		320	}
		321
		322	tasks.register('probe') {
		323	dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
		324
		325	doLast {
		326	def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
		327	assert new File(bundleDir, 'base.js').exists()
		328	assert new File(bundleDir, 'marker.txt').exists()
		329	}
		330	}
		331	""");
		332
		333	BuildResult result = runner("probe").build();
		334
		335	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
		336	}
		337
		338	@Test
		339	void failsOnUnknownVariantReference() throws Exception {
		340	writeSettings("variant-artifacts-missing-variant");
		341	writeBuildFile("""
		342	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		343
		344	variants.layers.create('main')
		345
		346	variantArtifacts {
		347	variant('browser') {
		348	slot('mainJs') {
		349	fromVariant {
		350	output('js')
		351	}
		352	}
		353	}
		354	}
		355	""");
		356
		357	assertBuildFails("isn't declared", "help");
		358	}
		359
		360	@Test
		361	void failsOnUnknownRoleReference() throws Exception {
		362	writeSettings("variant-artifacts-missing-role");
		363	writeBuildFile("""
		364	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		365
		366	variants.layers.create('main')
		367	variants.roles.create('main')
		368	variants.variant('browser') {
		369	role('main') {
		370	layers('main')
		371	}
		372	}
		373
		374	variantArtifacts {
		375	variant('browser') {
		376	slot('mainJs') {
		377	fromRole('test') {
		378	output('js')
		379	}
		380	}
		381	}
		382	}
		383	""");
		384
		385	assertBuildFails("Role projection for variant 'browser' and role 'test' not found", "help");
		386	}
		387
		388	@Test
		389	void failsWhenPrimarySlotIsMissingForMultipleSlots() throws Exception {
		390	writeSettings("variant-artifacts-missing-primary");
		391	writeBuildFile("""
		392	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		393
		394	variants.layers.create('main')
		395	variants.roles.create('main')
		396	variants.variant('browser') {
		397	role('main') {
		398	layers('main')
		399	}
		400	}
		401
		402	variantSources.layer('main') {
		403	declareOutputs('types', 'js')
		404	}
		405
		406	variantArtifacts {
		407	variant('browser') {
		408	slot('typesPackage') {
		409	fromVariant {
		410	output('types')
		411	}
		412	}
		413	slot('js') {
		414	fromVariant {
		415	output('js')
		416	}
		417	}
		418	}
		419	}
		420
		421	tasks.register('probe') {
		422	doLast {
		423	variantArtifacts.whenAvailable { ctx ->
		424	def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
		425	ctx.findOutgoing(browser).get().primarySlot.get()
		426	}
		427	}
		428	}
		429	""");
		430
		431	assertBuildFails("Multiple slots declared for browser, please specify primary slot explicitly", "probe");
		432	}
		433
		434	@Test
		435	void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
		436	writeSettings("variant-artifacts-layer-outside-topology");
		437	writeBuildFile("""
		438	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		439
		440	variants.layers.create('mainBase')
		441	variants.layers.create('extra')
		442	variants.roles.create('main')
		443	variants.variant('browser') {
		444	role('main') {
		445	layers('mainBase')
		446	}
		447	}
		448
		449	variantArtifacts {
		450	variant('browser') {
		451	slot('extraJs') {
		452	fromLayer('extra') {
		453	output('js')
		454	}
		455	}
		456	}
		457	}
		458	""");
		459
		460	assertBuildFails("Compile unit for variant 'browser' and layer 'extra' not found", "help");
		461	}
		462
		463	@Test
		464	void preservesPrimaryResolutionAndAllowsSecondaryArtifactSelection() throws Exception {
		465	writeFile("settings.gradle", """
		466	rootProject.name = 'variant-artifacts-resolution'
		467	include 'producer', 'consumer'
		468	""");
		469	writeFile("producer/inputs/types.d.ts", "export type Foo = string\n");
		470	writeFile("producer/inputs/index.js", "export const foo = 'bar'\n");
		471	writeBuildFile("""
		472	import org.gradle.api.attributes.Attribute
		473
		474	def variantAttr = Attribute.of('test.variant', String)
		475	def slotAttr = Attribute.of('test.slot', String)
		476
		477	subprojects {
		478	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		479	}
		480
		481	project(':producer') {
		482	variants.layers.create('main')
		483	variants.roles.create('main')
		484	variants.variant('browser') {
		485	role('main') {
		486	layers('main')
		487	}
		488	}
		489
		490	variantSources.layer('main') {
		491	declareOutputs('types', 'js')
		492	registerOutput('types', layout.projectDirectory.file('inputs/types.d.ts'))
		493	registerOutput('js', layout.projectDirectory.file('inputs/index.js'))
		494	}
		495
		496	variantArtifacts {
		497	variant('browser') {
		498	primarySlot('typesPackage') {
		499	fromVariant {
		500	output('types')
		501	}
		502	}
		503	slot('js') {
		504	fromVariant {
		505	output('js')
		506	}
		507	}
		508	}
		509
		510	whenOutgoingConfiguration { publication ->
		511	publication.configuration {
		512	attributes.attribute(variantAttr, publication.variant.name)
		513	}
		514	}
		515
		516	whenOutgoingSlot { publication ->
		517	publication.artifactAttributes {
		518	attribute(slotAttr, publication.artifactSlot.slot.name)
		519	}
		520	}
		521	}
		522
		523	}
		524
		525	project(':consumer') {
		526	configurations {
		527	compileView {
		528	canBeResolved = true
		529	canBeConsumed = false
		530	canBeDeclared = true
		531	attributes {
		532	attribute(variantAttr, 'browser')
		533	attribute(slotAttr, 'typesPackage')
		534	}
		535	}
		536	}
		537
		538	dependencies {
		539	compileView project(':producer')
		540	}
		541
		542	tasks.register('probe') {
		543	doLast {
		544	def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
		545	def jsFiles = configurations.compileView.incoming.artifactView {
		546	attributes {
		547	attribute(slotAttr, 'js')
		548	}
		549	}.files.files.collect { it.name }.sort().join(',')
		550
		551	println('compileFiles=' + compileFiles)
		552	println('jsFiles=' + jsFiles)
		553	}
		554	}
		555	}
		556	""");
		557
		558	BuildResult result = runner(":consumer:probe").build();
		559
		560	assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
		561	assertTrue(result.getOutput().contains("jsFiles=js"));
		562	}
		563	}

variants/src/main/java/org/implab/gradle/variants/SourcesPlugin.java ~~common/src/main/java/org/implab/gradle/common/sources/SourcesPlugin.java~~ renamed +2 -1

-            package org.implab.gradle.common.sources;
+            package org.implab.gradle.variants;
             import org.gradle.api.GradleException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
+            import org.implab.gradle.variants.sources.GenericSourceSet;
             /**
              * This plugin creates a {@code sources} extension which is
              * a container for {@link GenericSourceSet}.
              *
              */
             public abstract class SourcesPlugin implements Plugin<Project> {
                 private static final Logger logger = Logging.getLogger(SourcesPlugin.class);
                 private static final String SOURCES_EXTENSION_NAME = "sources";
                 @Override
                 public void apply(Project target) {
                     logger.debug("Registering '{}' extension on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                     var sources = target.getObjects().domainObjectContainer(GenericSourceSet.class);
                     target.getExtensions().add(SOURCES_EXTENSION_NAME, sources);
                 }
                 public static NamedDomainObjectContainer<GenericSourceSet> getSourcesExtension(Project target) {
                     var extensions = target.getExtensions();
                     @SuppressWarnings("unchecked")
                     var extension = (NamedDomainObjectContainer<GenericSourceSet>) extensions.findByName(SOURCES_EXTENSION_NAME);
                     if (extension == null) {
                         logger.error("Sources extension '{}' isn't found on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                         throw new GradleException("Sources extension isn't found");
                     }
                     logger.debug("Resolved '{}' extension on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                     return extension;
                 }
             }

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

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

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

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

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

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

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingConfigurationSlotSpec.java 0 -21

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Action;
-            import org.gradle.api.Task;
             import org.gradle.api.attributes.AttributeContainer;
             import groovy.lang.Closure;
             import org.implab.gradle.common.core.lang.Closures;
             /**
              * Materialized outgoing publication state of a single slot.
              *
              * <p>This type is a DSL facade to represent already created publication-facing state. Slot-specific
              * publication tweaks should be applied here rather than through {@link OutgoingConfigurationSpec}, which
              * is limited to the root outgoing configuration of the variant.
              */
             public interface OutgoingConfigurationSlotSpec {
                 /**
                  * Returns the published slot identity.
                  *
                  * @return slot identity
                  */
                 ArtifactSlot getArtifactSlot();
                 /**
-                 * Returns the assembly backing the published slot.
-                 * @return slot assembly
-                 */
-                ArtifactAssembly getAssembly();
-                /**
                  * Returns whether this slot is the primary outgoing artifact set of the variant.
                  *
                  * @return {@code true} for the primary slot
                  */
                 boolean isPrimary();
                 /**
-                 * Configures the task producing the slot artifact.
-                 * @param action task configuration action
-                 */
-                default void assemblyTask(Action<? super Task> action) {
-                    getAssembly().getAssemblyTask().configure(action);
-                default void assemblyTask(Closure<?> closure) {
-                    assemblyTask(Closures.action(closure));
-                /**
                  * Configures attributes of this slot publication.
                  *
                  * @param action artifact attribute configuration action
                  */
                 void artifactAttributes(Action<? super AttributeContainer> action);
                 default void artifactAttributes(Closure<?> closure) {
                     artifactAttributes(Closures.action(closure));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/MaterializationPolicyHandler.java +8 -19

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

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

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.LinkedHashMap;
             import java.util.Map;
             import java.util.Optional;
             import java.util.Set;
             import java.util.function.Consumer;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.artifacts.ConfigurationContainer;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Property;
+            import org.implab.gradle.internal.IdentityContainerFactory;
             import org.implab.gradle.internal.ReplayableQueue;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
             import org.implab.gradle.variants.artifacts.Slot;
             import org.implab.gradle.variants.core.Variant;
             /**
              * Реестр исходящих вариантов. Связывает исходящие конфигурации с вариантами
              * сборки. Связь устанавливается 1:1.
              */
             @NonNullByDefault
             public class OutgoingRegistry {
                 private final Map<Variant, OutgoingVariant> outgoingByVariant = new LinkedHashMap<>();
                 private final ReplayableQueue<OutgoingVariant> outgoingVariants = new ReplayableQueue<>();
                 private final ConfigurationContainer configurations;
                 private final ObjectFactory objects;
                 private final Set<Variant> declaredVariants;
                 public OutgoingRegistry(
                         ConfigurationContainer configurations,
                         ObjectFactory objects,
                         Set<Variant> declaredVariants) {
                     this.configurations = configurations;
                     this.objects = objects;
                     this.declaredVariants = declaredVariants;
                 }
                 public Optional<OutgoingVariant> find(Variant variant) {
                     return Optional.ofNullable(outgoingByVariant.get(variant));
                 }
                 public OutgoingVariant maybeCreate(Variant variant) {
                     return find(variant).orElseGet(() -> create(variant));
                 }
                 public OutgoingVariant create(Variant variant) {
                     if (!declaredVariants.contains(variant))
                         throw new InvalidUserDataException("Variant " + variant + " isn't declared");
                     if (outgoingByVariant.containsKey(variant))
                         throw new InvalidUserDataException("Outgoing variant " + variant + " already exists");
                     var configuration = configurations.consumable(outgoingConfigurationName(variant));
                     var outgoing = new Outgoing(variant, configuration);
                     outgoingByVariant.put(variant, outgoing);
                     outgoingVariants.add(outgoing);
                     return outgoing;
                 }
                 /**
                  * Replayable hook which is applied when an outgoing variant is defined
                  *
                  * @param action
                  */
                 public void configureEach(Consumer<? super OutgoingVariant> action) {
                     outgoingVariants.forEach(action);
                 }
                 private String outgoingConfigurationName(Variant variant) {
                     return variant.getName() + "Elements";
                 }
                 private class Outgoing implements OutgoingVariant {
                     private final Variant variant;
                     private final NamedDomainObjectProvider<? extends Configuration> configurationProvider;
                     private final NamedDomainObjectContainer<Slot> slots;
                     private final Property<Slot> primarySlot;
                     public Outgoing(
                             Variant variant,
                             NamedDomainObjectProvider<? extends Configuration> configurationProvider) {
                         this.variant = variant;
                         this.configurationProvider = configurationProvider;
-                        this.slots = objects.domainObjectContainer(Slot.class);
+                        this.slots = IdentityContainerFactory.create(objects, Slot.class);
                         this.primarySlot = objects.property(Slot.class);
                         primarySlot.finalizeValueOnRead();
                     }
                     @Override
                     public Property<Slot> getPrimarySlot() {
                         return primarySlot;
                     }
                     @Override
                     public Variant getVariant() {
                         return variant;
                     }
                     @Override
                     public NamedDomainObjectProvider<? extends Configuration> getConfiguration() {
                         return configurationProvider;
                     }
                     @Override
                     public NamedDomainObjectContainer<Slot> getSlots() {
                         return slots;
                     }
                 }
             }

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

             package org.implab.gradle.variants.sources;
             import java.util.HashMap;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Optional;
             import java.util.Set;
             import java.util.stream.Collectors;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
             @NonNullByDefault
             public final class CompileUnitsView {
                 private final VariantsView variants;
                 private final Map<Variant, Set<CompileUnit>> unitsByVariant = new HashMap<>();
                 private CompileUnitsView(VariantsView variants) {
                     this.variants = variants;
                 }
                 public Set<CompileUnit> getUnits() {
                     return variants.getEntries().stream()
                             .map(CompileUnit::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public Set<CompileUnit> getUnitsForVariant(Variant variant) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     return unitsByVariant.computeIfAbsent(variant, key -> variants
                             .getEntriesForVariant(variant).stream()
                             .map(CompileUnit::of)
                             .collect(Collectors.toUnmodifiableSet()));
                 }
                 public Optional<CompileUnit> findUnit(Variant variant, Layer layer) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     Objects.requireNonNull(layer, "Layer can't be null");
                     return getUnitsForVariant(variant).stream()
                             .filter(u -> u.layer().equals(layer))
                             .findAny();
                 }
                 public boolean contains(Variant variant, Layer layer) {
                     return findUnit(variant, layer).isPresent();
                 }
                 /**
                  * In which logical roles this compile unit participates.
                  */
                 public Set<Role> getRoles(CompileUnit unit) {
                     Objects.requireNonNull(unit, "Compile unit can't be null");
                     return variants.getEntriesForVariant(unit.variant()).stream()
                             .filter(entry -> entry.layer().equals(unit.layer()))
                             .map(VariantRoleLayer::role)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public CompileUnit requireUnit(Variant variant, Layer layer) {
                     return findUnit(variant, layer)
                             .orElseThrow(() -> new IllegalArgumentException(
                                     "Compile unit for variant '" + variant.getName()
                                             + "' and layer '" + layer.getName() + "' not found"));
                 }
                 public static CompileUnitsView of(VariantsView variantsView) {
                     Objects.requireNonNull(variantsView, "variantsView can't be null");
                     return new CompileUnitsView(variantsView);
                 }
-            }
  No newline at end of file

variants/src/main/java/org/implab/gradle/variants/sources/GenericSourceSet.java ~~common/src/main/java/org/implab/gradle/common/sources/GenericSourceSet.java~~ renamed +1 -1

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

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

             package org.implab.gradle.variants.sources;
             import java.util.HashMap;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Optional;
             import java.util.Set;
             import java.util.stream.Collectors;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             public final class RoleProjectionsView {
                 private final VariantsView variants;
                 private final Map<Variant, Set<RoleProjection>> projectionsByVariant = new HashMap<>();
                 private RoleProjectionsView(VariantsView variants) {
                     this.variants = variants;
                 }
                 public Set<RoleProjection> getProjections() {
                     return variants.getEntries().stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public Set<RoleProjection> getProjectionsForVariant(Variant variant) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     return projectionsByVariant.computeIfAbsent(variant, key -> variants
                             .getEntriesForVariant(variant).stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet()));
                 }
                 public Set<RoleProjection> getProjectionsForRole(Role role) {
                     Objects.requireNonNull(role, "Role can't be null");
                     return variants.getEntriesForRole(role).stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public Optional<RoleProjection> findProjection(Variant variant, Role role) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     Objects.requireNonNull(role, "Role can't be null");
                     return variants.getEntriesForVariant(variant).stream()
                             .filter(entry -> entry.role().equals(role))
                             .map(RoleProjection::of)
                             .findAny();
                 }
                 public boolean contains(Variant variant, Role role) {
                     return findProjection(variant, role).isPresent();
                 }
                 public Set<CompileUnit> getUnits(RoleProjection projection) {
                     Objects.requireNonNull(projection, "Role projection can't be null");
                     return variants.getEntriesForVariant(projection.variant()).stream()
                             .filter(entry -> entry.role().equals(projection.role()))
                             .map(CompileUnit::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public RoleProjection requireProjection(Variant variant, Role role) {
                     return findProjection(variant, role)
                             .orElseThrow(() -> new IllegalArgumentException(
                                     "Role projection for variant '" + variant.getName()
                                             + "' and role '" + role.getName() + "' not found"));
                 }
                 public Set<Layer> getLayers(RoleProjection projection) {
                     return getUnits(projection).stream()
                             .map(CompileUnit::layer)
                             .collect(java.util.stream.Collectors.toUnmodifiableSet());
                 }
                 public static RoleProjectionsView of(VariantsView variantsView) {
                     return new RoleProjectionsView(variantsView);
                 }
-            }
  No newline at end of file

variants/src/main/java/org/implab/gradle/variants/sources/SourceSetMaterializer.java 0 -1

             package org.implab.gradle.variants.sources;
             import org.gradle.api.NamedDomainObjectProvider;
-            import org.implab.gradle.common.sources.GenericSourceSet;
             /**
              * Materializes symbolic source set names into actual {@link GenericSourceSet}
              * instances.
              *
              * <p>Symbolic names are assigned from the finalized compile-unit model using
              * the selected
              * {@link VariantSourcesExtension#namingPolicy(org.gradle.api.Action)}.
              */
             public interface SourceSetMaterializer {
                 /**
                  * Returns a lazy provider for the source set corresponding to the compile unit.
                  *
                  * <p>The provider is stable and cached per compile unit.
                  */
                 NamedDomainObjectProvider<GenericSourceSet> getSourceSet(CompileUnit unit);
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesContext.java 0 -1

             package org.implab.gradle.variants.sources;
             import org.gradle.api.Action;
-            import org.implab.gradle.common.sources.GenericSourceSet;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             /**
              * Registry of symbolic source set names produced by sources projection.
              *
              * <p>Identity in this registry is the {@link GenericSourceSet} name assigned
              * by the finalized
              * {@link VariantSourcesExtension#namingPolicy(org.gradle.api.Action)}.
              */
             public interface VariantSourcesContext {
                /**
                  * Finalized core model.
                  */
                 VariantsView getVariants();
                 /**
                  * Derived compile-side view.
                  */
                 CompileUnitsView getCompileUnits();
                 /**
                  * Derived role-side view.
                  */
                 RoleProjectionsView getRoleProjections();
                 /**
                  * Lazy source set provider service.
                  */
                 SourceSetMaterializer getSourceSets();
                 /**
                  * Configures all GenericSourceSets produced from the given layer.
                  *
                  * The action is applied:
                  * - to already materialized source sets of this layer
                  * - to all future source sets of this layer
                  *
                  * <p>For future source sets, selector precedence and registration order are
                  * preserved by the materializer.
                  *
                  * <p>For already materialized source sets, behavior is governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
                  * In warn/allow modes the action is applied as a late imperative step and does
                  * not retroactively restore selector precedence.
                  */
                 void configureLayer(Layer layer, Action<? super GenericSourceSet> action);
                 /**
                  * Configures all GenericSourceSets produced from the given variant.
                  *
                  * <p>Late application semantics for already materialized source sets are
                  * governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
                  */
                 void configureVariant(Variant variant, Action<? super GenericSourceSet> action);
                 /**
                  * Configures the GenericSourceSet produced from the given compile unit.
                  *
                  * <p>Late application semantics for already materialized source sets are
                  * governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
                  */
                 void configureUnit(CompileUnit unit, Action<? super GenericSourceSet> action);
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesExtension.java 0 -1

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

variants/src/main/java/org/implab/gradle/variants/sources/internal/DefaultVariantSourcesContext.java +1 -1

             package org.implab.gradle.variants.sources.internal;
             import java.util.HashMap;
             import java.util.Map;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectProvider;
-            import org.implab.gradle.common.sources.GenericSourceSet;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.implab.gradle.variants.sources.CompileUnitsView;
+            import org.implab.gradle.variants.sources.GenericSourceSet;
             import org.implab.gradle.variants.sources.RoleProjectionsView;
             import org.implab.gradle.variants.sources.SourceSetMaterializer;
             import org.implab.gradle.variants.sources.VariantSourcesContext;
             public class DefaultVariantSourcesContext implements VariantSourcesContext {
                 private final VariantsView variantsView;
                 private final CompileUnitsView compileUnitsView;
                 private final RoleProjectionsView roleProjectionsView;
                 private final SourceSetMaterializer sourceSetMaterializer;
                 private final SourceSetRegistry sourceSetRegistry;
                 private final CompileUnitNamer compileUnitNamer;
                 private final SourceSetConfigurationRegistry sourceSetConfigurationRegistry;
                 public DefaultVariantSourcesContext(
                         VariantsView variantsView,
                         CompileUnitsView compileUnitsView,
                         RoleProjectionsView roleProjectionsView,
                         CompileUnitNamer compileUnitNamer,
                         SourceSetRegistry sourceSetRegistry,
                         SourceSetConfigurationRegistry sourceSetConfigurationRegistry) {
                     this.variantsView = variantsView;
                     this.compileUnitNamer = compileUnitNamer;
                     this.compileUnitsView = compileUnitsView;
                     this.roleProjectionsView = roleProjectionsView;
                     this.sourceSetRegistry = sourceSetRegistry;
                     this.sourceSetConfigurationRegistry = sourceSetConfigurationRegistry;
                     sourceSetMaterializer = new LocalSourceSetMaterializer();
                 }
                 @Override
                 public VariantsView getVariants() {
                     return variantsView;
                 }
                 @Override
                 public CompileUnitsView getCompileUnits() {
                     return compileUnitsView;
                 }
                 @Override
                 public RoleProjectionsView getRoleProjections() {
                     return roleProjectionsView;
                 }
                 @Override
                 public SourceSetMaterializer getSourceSets() {
                     return sourceSetMaterializer;
                 }
                 @Override
                 public void configureLayer(Layer layer, Action<? super GenericSourceSet> action) {
                     sourceSetConfigurationRegistry.addLayerAction(layer, action);
                 }
                 @Override
                 public void configureVariant(Variant variant, Action<? super GenericSourceSet> action) {
                     sourceSetConfigurationRegistry.addVariantAction(variant, action);
                 }
                 @Override
                 public void configureUnit(CompileUnit unit, Action<? super GenericSourceSet> action) {
                     sourceSetConfigurationRegistry.addCompileUnitAction(unit, action);
                 }
                 class LocalSourceSetMaterializer implements SourceSetMaterializer {
                     private final Map<CompileUnit, NamedDomainObjectProvider<GenericSourceSet>> registeredSources = new HashMap<>();
                     @Override
                     public NamedDomainObjectProvider<GenericSourceSet> getSourceSet(CompileUnit unit) {
                         return registeredSources.computeIfAbsent(unit, k -> {
                             var sourcesName = compileUnitNamer.resolveName(unit);
                             sourceSetRegistry.whenMaterialized(sourcesName,
                                     sourceSet -> sourceSetConfigurationRegistry.applyConfiguration(unit, sourceSet));
                             return sourceSetRegistry.sourceSets().register(sourcesName);
                         });
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/internal/SourceSetConfigurationRegistry.java +1 -1

             package org.implab.gradle.variants.sources.internal;
             import java.text.MessageFormat;
             import java.util.LinkedHashMap;
             import java.util.LinkedList;
             import java.util.List;
             import java.util.Map;
             import java.util.function.Consumer;
             import java.util.function.Supplier;
             import java.util.stream.Collectors;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.Named;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
-            import org.implab.gradle.common.sources.GenericSourceSet;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.sources.CompileUnit;
+            import org.implab.gradle.variants.sources.GenericSourceSet;
             @NonNullByDefault
             public class SourceSetConfigurationRegistry {
                 private static final Logger logger = Logging.getLogger(SourceSetConfigurationRegistry.class);
                 private final Map<Layer, ReplayableQueue<GenericSourceSet>> sourcesByLayer = new LinkedHashMap<>();
                 private final Map<Variant, ReplayableQueue<GenericSourceSet>> sourcesByVariant = new LinkedHashMap<>();
                 private final Map<CompileUnit, ReplayableQueue<GenericSourceSet>> sourcesByUnit = new LinkedHashMap<>();
                 private final Supplier<LateConfigurationMode> lateConfigurationMode;
                 public SourceSetConfigurationRegistry(Supplier<LateConfigurationMode> lateConfigurationMode) {
                     this.lateConfigurationMode = lateConfigurationMode;
                 }
                 public void addLayerAction(Layer layer, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByLayer.computeIfAbsent(layer, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source sets for [layer={0}] layer already materialized",
                                     layer.getName()));
                 }
                 public void addVariantAction(Variant variant, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByVariant.computeIfAbsent(variant, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source sets for [variant={0}] variant already materialized",
                                     variant.getName()));
                 }
                 public void addCompileUnitAction(CompileUnit unit, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source set for [variant={0}, layer={1}] already materialed",
                                     unit.variant().getName(),
                                     unit.layer().getName()));
                 }
                 private void addToActions(
                         ReplayableQueue<GenericSourceSet> actions,
                         Action<? super GenericSourceSet> action,
                         String assertMessage) {
                     assertLazyConfiguration(actions.values(), assertMessage);
                     actions.forEach(action::execute);
                 }
                 void assertLazyConfiguration(List<GenericSourceSet> sets, String message) {
                     if (sets.size() == 0)
                         return;
                     var names = sets.stream().map(Named::getName).collect(Collectors.joining(", "));
                     switch (lateConfigurationMode.get()) {
                         case FAIL:
                             throw new IllegalStateException(message + " [" + names + "]");
                         case WARN:
                             logger.warn(message + "\n\t" + names);
                             break;
                         default:
                             break;
                     }
                 }
                 public void applyConfiguration(CompileUnit unit, GenericSourceSet sourceSet) {
                     sourcesByVariant.computeIfAbsent(unit.variant(), key -> new ReplayableQueue<>()).add(sourceSet);
                     sourcesByLayer.computeIfAbsent(unit.layer(), key -> new ReplayableQueue<>()).add(sourceSet);
                     sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()).add(sourceSet);
                 }
                 class ReplayableQueue<T> {
                     private final List<Consumer<? super T>> consumers = new LinkedList<>();
                     private final List<T> values = new LinkedList<>();
                     public void add(T value) {
                         consumers.forEach(consumer -> consumer.accept(value));
                         values.add(value);
                     }
                     List<T> values() {
                         return List.copyOf(values);
                     }
                     public void forEach(Consumer<? super T> consumer) {
                         values.forEach(consumer);
                         consumers.add(consumer);
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/internal/SourceSetRegistry.java +1 -1

             package org.implab.gradle.variants.sources.internal;
             import java.util.HashMap;
             import java.util.Map;
             import java.util.function.Consumer;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.core.lang.Deferred;
-            import org.implab.gradle.common.sources.GenericSourceSet;
+            import org.implab.gradle.variants.sources.GenericSourceSet;
             public class SourceSetRegistry {
                 private final Map<String, Deferred<GenericSourceSet>> materialized = new HashMap<>();
                 private final NamedDomainObjectContainer<GenericSourceSet> sourceSets;
                 private final ObjectFactory objectFactory;
                 public SourceSetRegistry(ObjectFactory objectFactory) {
                     this.objectFactory = objectFactory;
                     this.sourceSets = objectFactory.domainObjectContainer(GenericSourceSet.class, this::createSourceSet);
                 }
                 void forEachMaterialized(Consumer<? super GenericSourceSet> consumer) {
                     materialized.values().stream()
                         .filter(Deferred::resolved)
                         .map(Deferred::value)
                         .forEach(consumer);
                 }
                 public NamedDomainObjectContainer<GenericSourceSet> sourceSets() {
                     return sourceSets;
                 }
                 public void whenMaterialized(String name, Consumer<? super GenericSourceSet> consumer) {
                     materialized(name).whenResolved(consumer);
                 }
                 private GenericSourceSet createSourceSet(String name) {
                     var sourceSet = objectFactory.newInstance(GenericSourceSet.class, name);
                     materialized(name).resolve(sourceSet);
                     return sourceSet;
                 }
                 private Deferred<GenericSourceSet> materialized(String name) {
                     return materialized.computeIfAbsent(name, k -> new Deferred<>());
                 }
             }

variants/src/main/resources/META-INF/gradle-plugins/org.implab.gradle-variants-artifacts.properties ~~common/src/main/resources/META-INF/gradle-plugins/org.implab.gradle-variants-artifacts.properties~~ renamed +1 -1

	@@ -1,1 +1,1
	1	implementation-class=org.implab.gradle.~~common.source~~s.VariantArtifactsPlugin		1	implementation-class=org.implab.gradle.variants.VariantArtifactsPlugin

variants/src/main/resources/META-INF/gradle-plugins/org.implab.gradle-variants-sources.properties ~~common/src/main/resources/META-INF/gradle-plugins/org.implab.gradle-variants-sources.properties~~ renamed +1 -1

	@@ -1,1 +1,1
	1	implementation-class=org.implab.gradle.~~common.source~~s.VariantsSourcesPlugin		1	implementation-class=org.implab.gradle.variants.VariantSourcesPlugin

variants/src/main/resources/META-INF/gradle-plugins/org.implab.gradle-variants.properties ~~common/src/main/resources/META-INF/gradle-plugins/org.implab.gradle-variants.properties~~ renamed +1 -1

	@@ -1,1 +1,1
	1	implementation-class=org.implab.gradle.~~common.source~~s.VariantsPlugin		1	implementation-class=org.implab.gradle.variants.VariantsPlugin

variants/src/test/java/org/implab/gradle/variants/AbstractFunctionalTest.java +17 -2

             package org.implab.gradle.variants;
             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.LinkedHashSet;
             import java.util.List;
             import java.util.stream.Collectors;
             import org.gradle.testkit.runner.GradleRunner;
             import org.gradle.testkit.runner.UnexpectedBuildFailure;
-            import org.implab.gradle.common.sources.GenericSourceSet;
+            import org.implab.gradle.common.core.lang.Deferred;
+            import org.implab.gradle.variants.sources.GenericSourceSet;
             import org.junit.jupiter.api.io.TempDir;
             abstract class AbstractFunctionalTest {
                 private static final String SETTINGS_FILE = "settings.gradle";
                 private static final String BUILD_FILE = "build.gradle";
                 @TempDir
                 Path testProjectDir;
                 protected void writeSettings(String rootProjectName) throws IOException {
                     writeFile(SETTINGS_FILE, "rootProject.name = '" + rootProjectName + "'\n");
                 }
                 protected void writeBuildFile(String body) throws IOException {
                     writeFile(BUILD_FILE, buildscriptClasspathBlock() + "\n" + body);
                 }
                 protected GradleRunner runner(String... arguments) {
                     return GradleRunner.create()
                             .withProjectDir(testProjectDir.toFile())
                             .withArguments(arguments)
                             .forwardOutput();
                 }
                 protected void assertBuildFails(String expectedError, String... arguments) {
                     var ex = org.junit.jupiter.api.Assertions.assertThrows(
                             UnexpectedBuildFailure.class,
                             () -> runner(arguments).build());
                     var output = ex.getBuildResult().getOutput();
                     assertTrue(output.contains(expectedError), () -> "Expected [" + expectedError + "] in output:\n" + output);
                 }
                 private static String buildscriptClasspathBlock() {
                     var classpath = pluginClasspath().stream()
                             .map(file -> "'" + file.getAbsolutePath().replace("\\", "\\\\") + "'")
                             .collect(Collectors.joining(", "));
                     return """
                             buildscript {
                                 dependencies {
                                     classpath files(%s)
                                 }
                             }
                             """.formatted(classpath);
                 }
                 private static List<File> pluginClasspath() {
                     try {
                         var files = new LinkedHashSet<File>();
                         files.add(codeSource(VariantSourcesPlugin.class));
+                        files.add(resourceRoot("META-INF/gradle-plugins/org.implab.gradle-variants.properties"));
                         files.add(codeSource(GenericSourceSet.class));
+                        files.add(codeSource(Deferred.class));
                         return List.copyOf(files);
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to build plugin classpath for test", e);
                     }
                 }
                 private static File codeSource(Class<?> type) throws Exception {
                     return Path.of(type.getProtectionDomain().getCodeSource().getLocation().toURI()).toFile();
                 }
-                private void writeFile(String relativePath, String content) throws IOException {
+                private static File resourceRoot(String resourceName) throws Exception {
+                    var url = VariantSourcesPlugin.class.getClassLoader().getResource(resourceName);
+                    if (url == null)
+                        throw new IllegalStateException("Classpath resource isn't found: " + resourceName);
+                    var path = Path.of(url.toURI());
+                    var segments = resourceName.split("/").length;
+                    for (var i = 0; i < segments; i++)
+                        path = path.getParent();
+                    return path.toFile();
+                }
+                protected void writeFile(String relativePath, String content) throws IOException {
                     Path path = testProjectDir.resolve(relativePath);
                     Files.createDirectories(path.getParent());
                     Files.writeString(path, content);
                 }
             }

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

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

common/src/main/java/org/implab/gradle/common/sources/ArtifactAssembly.java removed 0 -19

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/ArtifactAssemblyRegistry.java removed 0 -76

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/BuildRole.java removed 0 -59

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/BuildVariant.java removed 0 -119

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/BuildVariantsExtension.java removed 0 -235

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/LayerBinding.java removed 0 -83

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/LayerBindingSpec.java removed 0 -41

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/LayoutLayer.java removed 0 -22

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/OutgoingArtifactSlotPublication.java removed 0 -63

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/OutgoingVariantPublication.java removed 0 -89

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/SourceSetRegistration.java removed 0 -33

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/SourceSetUsageBinding.java removed 0 -37

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantArtifact.java removed 0 -144

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactSlot.java removed 0 -242

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsExtension.java removed 0 -224

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsPlugin.java removed 0 -184

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsResolver.java removed 0 -126

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantSourcesExtension.java removed 0 -317

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantsPlugin.java removed 0 -39

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantsSourcesPlugin.java removed 0 -33

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/package-info.java removed 0 -16

NO CONTENT: file was removed

common/src/test/java/org/implab/gradle/common/sources/VariantsArtifactsPluginFunctionalTest.java removed 0 -608

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (608 lines changed) Show them Hide them

common/src/test/java/org/implab/gradle/common/sources/VariantsPluginFunctionalTest.java removed 0 -248

NO CONTENT: file was removed

common/src/test/java/org/implab/gradle/common/sources/VariantsSourcesPluginFunctionalTest.java removed 0 -444

	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