implab/gradle-common Commit - r35:389e9d6c7860

Refactor variant artifact slots into contribution-based inputs

cin -

r35:389e9d6c7860 default

parent child

Context file:

r35:389e9d6c7860

Collapse all files

common/src/main/java/org/implab/gradle/common/sources/GenericSourceSet.java +7 -3

             package org.implab.gradle.common.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 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 ConfigurableFileCollection output(String name) {
+                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) {
                     declaredOutputs.add(Objects.requireNonNull(name, "declareOutputs: The output name cannot be null"));
                     for (var x : extra)
                         declaredOutputs.add(Objects.requireNonNull(x, "declareOutputs: The output name cannot be null"));
                 }
                 /**
                  * Registers files produced elsewhere under the given output.
                  */
                 public void registerOutput(String name, Object... files) {
-                    output(name).from(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) {
-                    output(name).from(task.map(mapper::apply))
+                    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());
                 }
             }

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

             package org.implab.gradle.common.sources;
             import java.util.Optional;
             import javax.inject.Inject;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
+            /**
+             * Artifact model for one topology variant declared in
+             * {@link VariantArtifactsExtension}.
+             *
+             * <p>A {@code VariantArtifact} groups one or more
+             * {@link VariantArtifactSlot artifact representation slots}. The primary slot
+             * becomes the main artifact of {@code <variant>Elements}; remaining slots are
+             * published as secondary outgoing variants by {@link VariantArtifactsPlugin}.
+             */
             @NonNullByDefault
             public class VariantArtifact implements Named {
                 private final String name;
                 private final NamedDomainObjectContainer<VariantArtifactSlot> slots;
                 private String primarySlotName;
                 private boolean finalized;
                 @Inject
                 public VariantArtifact(String name, NamedDomainObjectContainer<VariantArtifactSlot> slots) {
                     this.name = normalize(name, "variant artifact name must not be null or blank");
                     this.slots = slots;
                     slots.all(slot -> {
                         if (finalized)
                             throw new InvalidUserDataException(
                                     "Variant artifact '" + this.name + "' is finalized and cannot add slot '" + slot.getName() + "'");
                     });
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 public NamedDomainObjectContainer<VariantArtifactSlot> getSlots() {
                     return slots;
                 }
                 public VariantArtifactSlot slot(String name) {
                     return slot(name, slot -> {
                     });
                 }
                 public VariantArtifactSlot slot(String name, Action<? super VariantArtifactSlot> configure) {
                     ensureMutable("configure slots");
                     var slot = slots.maybeCreate(normalize(name, "slot name must not be null or blank"));
                     configure.execute(slot);
                     return slot;
                 }
                 public VariantArtifactSlot slot(
                         String name,
                         @DelegatesTo(value = VariantArtifactSlot.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return slot(name, Closures.action(configure));
                 }
                 public Optional<VariantArtifactSlot> findSlot(String slotName) {
                     return Optional.ofNullable(slots.findByName(normalize(slotName, "slot name must not be null or blank")));
                 }
                 public void primarySlot(String slotName) {
                     ensureMutable("configure primary slot");
                     primarySlotName = normalize(slotName, "primary slot name must not be null or blank");
                 }
                 public VariantArtifactSlot primarySlot(String slotName, Action<? super VariantArtifactSlot> configure) {
                     ensureMutable("configure primary slot");
                     var slot = slot(slotName, configure);
                     primarySlot(slot.getName());
                     return slot;
                 }
                 public VariantArtifactSlot primarySlot(
                         String slotName,
                         @DelegatesTo(value = VariantArtifactSlot.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return primarySlot(slotName, Closures.action(configure));
                 }
                 public Optional<String> findPrimarySlotName() {
                     return Optional.ofNullable(primarySlotName)
                             .or(() -> slots.getNames().size() == 1 ? Optional.of(slots.iterator().next().getName()) : Optional.empty());
                 }
                 public String requirePrimarySlotName() {
                     return findPrimarySlotName()
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant artifact '" + name + "' must declare primary slot because it has multiple slots"));
                 }
                 public Optional<VariantArtifactSlot> findPrimarySlot() {
                     return findPrimarySlotName().flatMap(this::findSlot);
                 }
                 public VariantArtifactSlot requirePrimarySlot() {
                     var resolvedPrimarySlotName = requirePrimarySlotName();
                     return findSlot(resolvedPrimarySlotName)
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant artifact '" + name + "' declares unknown primary slot '" + resolvedPrimarySlotName + "'"));
                 }
                 public VariantArtifactSlot requireSlot(String slotName) {
                     var normalizedSlotName = normalize(slotName, "slot name must not be null or blank");
                     return Optional.ofNullable(slots.findByName(normalizedSlotName))
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant artifact '" + name + "' doesn't declare slot '" + normalizedSlotName + "'"));
                 }
                 void finalizeModel() {
                     if (finalized)
                         return;
                     for (var slot : slots)
                         slot.finalizeModel();
                     finalized = true;
                 }
                 static String normalize(String value, String message) {
                     return Optional.ofNullable(value)
                             .map(String::trim)
                             .filter(trimmed -> !trimmed.isEmpty())
                             .orElseThrow(() -> new InvalidUserDataException(message));
                 }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("Variant artifact '" + name + "' is finalized and cannot " + operation);
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactSlot.java +144 -44

@@ -1,138 +1,238
1	package org.implab.gradle.common.sources;	1	package org.implab.gradle.common.sources;
2		2
3	import java.util.ArrayList;	3	import java.util.ArrayList;
		4	import java.util.Collection;
		5	import java.util.LinkedHashSet;
4	import java.util.List;	6	import java.util.List;
		7	import java.util.Set;
		8	import java.util.function.Consumer;
		9	import java.util.function.Predicate;
		10	import java.util.stream.Stream;
5		11
6	import javax.inject.Inject;	12	import javax.inject.Inject;
7		13
8	import org.eclipse.jdt.annotation.NonNullByDefault;	14	import org.eclipse.jdt.annotation.NonNullByDefault;
9	import org.gradle.api.Action;	15	import org.gradle.api.Action;
10	import org.gradle.api.InvalidUserDataException;	16	import org.gradle.api.InvalidUserDataException;
11	import org.gradle.api.Named;	17	import org.gradle.api.Named;
12	import org.implab.gradle.common.core.lang.Closures;	18	import org.implab.gradle.common.core.lang.Closures;
13		19
14	import groovy.lang.Closure;	20	import groovy.lang.Closure;
15	import groovy.lang.DelegatesTo;	21	import groovy.lang.DelegatesTo;
16		22
		23	/**
		24	* One artifact representation slot inside {@link VariantArtifact}.
		25	*
		26	* <p>
		27	* The DSL exposed by this type is topology-aware sugar over an internal
		28	* contribution model:
		29	* <ul>
		30	* <li>{@link #from(Object)} adds one direct contribution that does not depend
		31	* on {@link VariantSourcesExtension} bindings;</li>
		32	* <li>{@link #fromVariant(Action)}, {@link #fromRole(String, Action)} and
		33	* {@link #fromLayer(String, Action)} define where a contribution is active in
		34	* the variant/role/layer topology;</li>
		35	* <li>{@link OutputSelectionSpec#output(String)} defines which named output of
		36	* the matched {@link GenericSourceSet} should be added to the slot.</li>
		37	* </ul>
		38	*
		39	* <p>
		40	* Internally the slot stores contribution resolvers rather than raw output
		41	* names. Each contribution can later materialize itself against the
		42	* variant-specific source-set bindings and return:
		43	* <ul>
		44	* <li>a file notation object suitable for {@code files.from(...)}</li>
		45	* <li>a {@link BindingKey} used to deduplicate repeated logical inputs during
		46	* materialization</li>
		47	* </ul>
		48	*
		49	* <p>
		50	* Validation is intentionally separated from materialization: the slot keeps
		51	* topology references in {@link #referencedRoleNames()} and
		52	* {@link #referencedLayerNames()}, while the actual contribution pipeline is
		53	* exposed through {@link #bindings()}.
		54	*/
17	@NonNullByDefault	55	@NonNullByDefault
18	public class VariantArtifactSlot implements Named {	56	public class VariantArtifactSlot implements Named {
19	private final String name;	57	private final String name;
20	private final List<BindingR~~ule~~> ~~rule~~s = new ArrayList<>();	58	private final List<BindingResolver> bindings = new ArrayList<>();
		59	private final Set<String> referencedRoleNames = new LinkedHashSet<>();
		60	private final Set<String> referencedLayerNames = new LinkedHashSet<>();
21	private boolean finalized;	61	private boolean finalized;
22		62
23	@Inject	63	@Inject
24	public VariantArtifactSlot(String name) {	64	public VariantArtifactSlot(String name) {
25	this.name = VariantArtifact.normalize(name, "slot name must not be null or blank");	65	this.name = VariantArtifact.normalize(name, "slot name must not be null or blank");
26	}	66	}
27		67
28	@Override	68	@Override
29	public String getName() {	69	public String getName() {
30	return name;	70	return name;
31	}	71	}
32		72
33	public void fromVariant(Action<? super OutputSelectionSpec> configure) {	73	public void fromVariant(Action<? super OutputSelectionSpec> configure) {
34	addRules(BindingSelector.variant(), configure);	74	addContributions(context -> true, configure);
35	}	75	}
36		76
37	public void fromVariant(	77	public void fromVariant(
38	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {	78	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
39	fromVariant(Closures.action(configure));	79	fromVariant(Closures.action(configure));
40	}	80	}
41		81
42	public void fromRole(String roleName, Action<? super OutputSelectionSpec> configure) {	82	public void fromRole(String roleName, Action<? super OutputSelectionSpec> configure) {
43	~~addRules~~(~~BindingSelector~~.~~role~~(VariantArtifact.normalize(roleName, "role name must not be null or blank")),	83	var normalizedRoleName = VariantArtifact.normalize(roleName, "role name must not be null or blank");
44	configure);	84	addContributions(context -> context.roleName().equals(normalizedRoleName), configure);
		85	referencedRoleNames.add(normalizedRoleName);
45	}	86	}
46		87
47	public void fromRole(	88	public void fromRole(
48	String roleName,	89	String roleName,
49	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {	90	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
50	fromRole(roleName, Closures.action(configure));	91	fromRole(roleName, Closures.action(configure));
51	}	92	}
52		93
53	public void fromLayer(String layerName, Action<? super OutputSelectionSpec> configure) {	94	public void fromLayer(String layerName, Action<? super OutputSelectionSpec> configure) {
54	~~addRules~~(~~BindingSelector~~.~~layer~~(VariantArtifact.normalize(layerName, "layer name must not be null or blank")),	95	var normalizedLayerName = VariantArtifact.normalize(layerName, "layer name must not be null or blank");
55	configure);	96	addContributions(context -> context.layerName().equals(normalizedLayerName), configure);
		97	referencedLayerNames.add(normalizedLayerName);
56	}	98	}
57		99
58	public void fromLayer(	100	public void fromLayer(
59	String layerName,	101	String layerName,
60	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {	102	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
61	fromLayer(layerName, Closures.action(configure));	103	fromLayer(layerName, Closures.action(configure));
62	}	104	}
63		105
64	List<BindingRule> bindingRules() {	106	/**
65	return List.copyOf(rules);	107	* Adds one direct slot contribution.
		108	*
		109	* <p>The supplied object is forwarded as-is to {@code files.from(...)}
		110	* during slot materialization and does not depend on
		111	* {@link VariantSourcesExtension#whenBound(Action)} callbacks.
		112	*/
		113	public void from(Object files) {
		114	ensureMutable("configure sources");
		115
		116	if (files == null)
		117	throw new InvalidUserDataException("slot source must not be null");
		118
		119	var key = BindingKey.newUniqueKey("direct slot input for '" + name + "'");
		120	bindings.add((contexts, consumer) -> consumer.accept(new ResolvedBinding(key, files)));
		121	}
		122
		123	List<BindingResolver> bindings() {
		124	return List.copyOf(bindings);
		125	}
		126
		127	Set<String> referencedRoleNames() {
		128	return Set.copyOf(referencedRoleNames);
		129	}
		130
		131	Set<String> referencedLayerNames() {
		132	return Set.copyOf(referencedLayerNames);
66	}	133	}
67		134
68	void finalizeModel() {	135	void finalizeModel() {
69	finalized = true;	136	finalized = true;
70	}	137	}
71		138
72	private void addRules(BindingSelector selector, Action<? super OutputSelectionSpec> configure) {	139	private void addContributions(
		140	Predicate<SourceSetUsageBinding> selector,
		141	Action<? super OutputSelectionSpec> configure) {
73	ensureMutable("configure sources");	142	ensureMutable("configure sources");
74		143
75	var spec = new OutputSelectionSpec(selector);	144	var spec = new OutputSelectionSpec(selector);
76	configure.execute(spec);	145	configure.execute(spec);
77	rules.addAll(spec.rules());	146	spec.accept(bindings::add);
78	}	147	}
79		148
80	private void ensureMutable(String operation) {	149	private void ensureMutable(String operation) {
81	if (finalized)	150	if (finalized)
82	throw new InvalidUserDataException("Variant artifact slot '" + name + "' is finalized and cannot " + operation);	151	throw new InvalidUserDataException(
		152	"Variant artifact slot '" + name + "' is finalized and cannot " + operation);
83	}	153	}
84		154
		155	/**
		156	* Local DSL buffer for one {@code fromVariant/fromRole/fromLayer} block.
		157	*
		158	* <p>
		159	* The spec accumulates contributions locally and flushes them to the
		160	* owning slot only after the outer configure block completes successfully.
		161	*/
85	public final class OutputSelectionSpec {	162	public final class OutputSelectionSpec {
86	private final Binding~~Selector~~ selector;	163	private final Predicate<SourceSetUsageBinding> selector;
87	private final List<BindingR~~ule~~> ~~rule~~s = new ArrayList<>();	164	private final List<BindingResolver> bindings = new ArrayList<>();
88		165
89	private OutputSelectionSpec(Binding~~Selector~~ selector) {	166	private OutputSelectionSpec(Predicate<SourceSetUsageBinding> selector) {
90	this.selector = selector;	167	this.selector = selector;
91	}	168	}
92		169
93	public void output(String name) {	170	public void output(String name) {
94	rules.add(new BindingRule(selector,	171	var outputName = VariantArtifact.normalize(name, "output name must not be null or blank");
95	VariantArtifact.normalize(name, "output name must not be null or blank")));	172	bindings.add((contexts, consumer) -> contexts.stream()
		173	.filter(selector)
		174	.map(context -> resolveOutput(context, outputName))
		175	.forEach(consumer));
96	}	176	}
97		177
98	public void output(String name, String... extra) {	178	public void output(String name, String... extra) {
99	output(name);	179	Stream.concat(Stream.of(name), Stream.of(extra))
100	for (var item : extra)	180	.forEach(this::output);
101	output(item);
102	}	181	}
103		182
104	private List<BindingRule> rules() {	183	private ResolvedBinding resolveOutput(SourceSetUsageBinding context, String outputName) {
105	return List.copyOf(rules);	184	var key = new SourceSetOutputKey(context.sourceSetName(), outputName);
		185	var files = context.sourceSet().map(sourceSet -> sourceSet.output(outputName));
		186	return new ResolvedBinding(key, files);
		187	}
		188
		189	void accept(Consumer<? super BindingResolver> consumer) {
		190	bindings.forEach(consumer);
106	}	191	}
107	}	192	}
108		193
109	record BindingRule(BindingSelector selector, String outputName) {	194	@FunctionalInterface
110	boolean matches(SourceSetUsageBinding context) {	195	interface BindingResolver {
111	return switch (selector.kind()) {	196	void resolve(Collection<SourceSetUsageBinding> contexts, Consumer<? super ResolvedBinding> consumer);
112	case VARIANT -> true;	197	}
113	case ROLE -> selector.value().equals(context.roleName());	198
114	case LAYER -> selector.value().equals(context.layerName());	199	/**
		200	* Materialized slot contribution for one concrete source-set binding.
		201	*/
		202	record ResolvedBinding(BindingKey key, Object files) {
		203	}
		204
		205	/**
		206	* Marker key for deduplicating logical slot inputs during materialization.
		207	*
		208	* <p>
		209	* Semantic keys such as {@link SourceSetOutputKey} collapse repeated
		210	* references to the same logical output. Identity keys created via
		211	* {@link #newUniqueKey()} or {@link #newUniqueKey(String)} can be used by contributions
		212	* that must flow through the same pipeline but should never be merged.
		213	*/
		214	interface BindingKey {
		215	static BindingKey newUniqueKey(String hint) {
		216	return new BindingKey() {
		217	@Override
		218	public String toString() {
		219	return hint;
		220	}
115	};	221	};
116	}	222	}
		223
		224	static BindingKey newUniqueKey() {
		225	return newUniqueKey("unnamed");
		226	}
117	}	227	}
118		228
119	record BindingSelector(SelectorKind kind, String value) {	229	/**
120	static BindingSelector variant() {	230	* Stable dedupe key for one named output of one resolved source set.
121	return new BindingSelector(SelectorKind.VARIANT, "");	231	*/
122	}	232	record SourceSetOutputKey(String sourceSetName, String outputName) implements BindingKey {
123		233	@Override
124	static BindingSelector role(String roleName) {	234	public String toString() {
125	return new BindingSelector(SelectorKind.ROLE, roleName);	235	return "sourceSet '" + sourceSetName + "' output '" + outputName + "'";
126	}
127
128	static BindingSelector layer(String layerName) {
129	return new BindingSelector(SelectorKind.LAYER, layerName);
130	}	236	}
131	}	237	}
132
133	enum SelectorKind {
134	VARIANT,
135	ROLE,
136	LAYER
137	}	238	}
138	}

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsExtension.java +80 -38

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Optional;
+            import java.util.Set;
             import javax.inject.Inject;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
+            /**
+             * Root DSL and lifecycle holder for the {@code variantArtifacts} model.
+             *
+             * <p>This extension sits on top of the build topology defined by
+             * {@link BuildVariantsExtension} and the source-set materialization performed by
+             * {@link VariantSourcesExtension}:
+             * <ul>
+             * <li>{@link #variant(String, Action)} declares one outgoing artifact model per
+             * topology variant;</li>
+             * <li>each {@link VariantArtifact} declares one or more
+             * {@link VariantArtifactSlot slots};</li>
+             * <li>after topology finalization this extension validates the artifact model,
+             * freezes it and later receives replayable outgoing-publication callbacks via
+             * {@link #whenOutgoingVariant(Action)}.</li>
+             * </ul>
+             */
             @NonNullByDefault
             public abstract class VariantArtifactsExtension {
                 private final NamedDomainObjectContainer<VariantArtifact> variants;
                 private final ObjectFactory objects;
                 private final List<Action<? super OutgoingVariantPublication>> outgoingVariantActions = new ArrayList<>();
                 private final List<OutgoingVariantPublication> outgoingVariants = new ArrayList<>();
                 private boolean finalized;
                 @Inject
                 public VariantArtifactsExtension(ObjectFactory objects) {
                     this.objects = objects;
                     variants = objects.domainObjectContainer(VariantArtifact.class, this::newVariantArtifact);
                     variants.all(variant -> {
                         if (finalized)
                             throw new InvalidUserDataException(
                                     "variantArtifacts model is finalized and cannot add variant '" + variant.getName() + "'");
                     });
                 }
                 public NamedDomainObjectContainer<VariantArtifact> getVariants() {
                     return variants;
                 }
                 public VariantArtifact variant(String name) {
                     return variant(name, variant -> {
                     });
                 }
                 public VariantArtifact variant(String name, Action<? super VariantArtifact> configure) {
                     ensureMutable("configure variants");
                     var variant = variants.maybeCreate(VariantArtifact.normalize(name, "variant name must not be null or blank"));
                     configure.execute(variant);
                     return variant;
                 }
                 public VariantArtifact variant(
                         String name,
                         @DelegatesTo(value = VariantArtifact.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return variant(name, Closures.action(configure));
                 }
                 public Optional<VariantArtifact> findVariant(String variantName) {
                     return Optional
                             .ofNullable(variants.findByName(VariantArtifact.normalize(variantName, "variant name must not be null or blank")));
                 }
                 public VariantArtifact requireVariant(String variantName) {
                     var normalizedVariantName = VariantArtifact.normalize(variantName, "variant name must not be null or blank");
                     return findVariant(normalizedVariantName)
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant artifacts do not declare variant '" + normalizedVariantName + "'"));
                 }
                 public void whenOutgoingVariant(Action<? super OutgoingVariantPublication> action) {
                     outgoingVariantActions.add(action);
                     for (var publication : outgoingVariants)
                         action.execute(publication);
                 }
                 public void whenOutgoingVariant(
                         @DelegatesTo(value = OutgoingVariantPublication.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenOutgoingVariant(Closures.action(action));
                 }
                 public boolean isFinalized() {
                     return finalized;
                 }
                 void finalizeModel(BuildVariantsExtension topology) {
                     if (finalized)
                         return;
                     validate(topology);
                     for (var variant : variants)
                         variant.finalizeModel();
                     finalized = true;
                 }
                 void notifyOutgoingVariant(OutgoingVariantPublication publication) {
                     outgoingVariants.add(publication);
                     for (var action : outgoingVariantActions)
                         action.execute(publication);
                 }
                 private VariantArtifact newVariantArtifact(String name) {
                     return objects.newInstance(VariantArtifact.class, name, objects.domainObjectContainer(VariantArtifactSlot.class));
                 }
                 private void validate(BuildVariantsExtension topology) {
                     var errors = new ArrayList<String>();
-                    for (var variantArtifact : variants) {
+                    for (var variantArtifact : variants)
+                        validateVariantArtifact(topology, variantArtifact, errors);
+                    throwIfInvalid(errors);
+                }
+                private static void validateVariantArtifact(
+                        BuildVariantsExtension topology,
+                        VariantArtifact variantArtifact,
+                        List<String> errors) {
                     var topologyVariant = topology.find(variantArtifact.getName());
                     if (topologyVariant.isEmpty()) {
                         errors.add("Variant artifact '" + variantArtifact.getName() + "' references unknown variant '"
                                 + variantArtifact.getName() + "'");
-                            continue;
+                        return;
+                    }
+                    var topologyScope = TopologyScope.from(topologyVariant.get());
+                    validateTopologyReferences(variantArtifact, topologyScope, errors);
+                    validatePrimarySlot(variantArtifact, errors);
+                }
+                private static void validateTopologyReferences(
+                        VariantArtifact variantArtifact,
+                        TopologyScope topologyScope,
+                        List<String> errors) {
+                    for (var slot : variantArtifact.getSlots()) {
+                        validateSlotReferences(variantArtifact, slot, "role", slot.referencedRoleNames(), topologyScope.roleNames(), errors);
+                        validateSlotReferences(variantArtifact, slot, "layer", slot.referencedLayerNames(), topologyScope.layerNames(), errors);
+                    }
                 }
-                        validateVariantArtifact(variantArtifact, topologyVariant.get(), errors);
+                private static void validatePrimarySlot(VariantArtifact variantArtifact, List<String> errors) {
+                    if (variantArtifact.getSlots().isEmpty())
+                        return;
+                    if (variantArtifact.findPrimarySlotName().isEmpty()) {
+                        errors.add("Variant artifact '" + variantArtifact.getName()
+                                + "' must declare primary slot because it has multiple slots");
+                        return;
+                    }
+                    var primarySlotName = variantArtifact.requirePrimarySlotName();
+                    if (variantArtifact.findSlot(primarySlotName).isEmpty()) {
+                        errors.add("Variant artifact '" + variantArtifact.getName()
+                                + "' declares unknown primary slot '" + primarySlotName + "'");
+                    }
                 }
-                    if (!errors.isEmpty()) {
+                private static void validateSlotReferences(
+                        VariantArtifact variantArtifact,
+                        VariantArtifactSlot slot,
+                        String referenceKind,
+                        Set<String> referencedNames,
+                        Set<String> knownNames,
+                        List<String> errors) {
+                    for (var referencedName : referencedNames) {
+                        if (!knownNames.contains(referencedName)) {
+                            errors.add("Variant artifact '" + variantArtifact.getName() + "', slot '" + slot.getName()
+                                    + "' references unknown " + referenceKind + " '" + referencedName + "'");
+                        }
+                    }
+                }
+                private static void throwIfInvalid(List<String> errors) {
+                    if (errors.isEmpty())
+                        return;
                     var message = new StringBuilder("Invalid variantArtifacts model:");
                     for (var error : errors)
                         message.append("\n - ").append(error);
                     throw new InvalidUserDataException(message.toString());
                 }
-                private static void validateVariantArtifact(VariantArtifact variantArtifact, BuildVariant topologyVariant, List<String> errors) {
+                private record TopologyScope(Set<String> roleNames, Set<String> layerNames) {
+                    private static TopologyScope from(BuildVariant topologyVariant) {
                         var roleNames = new LinkedHashSet<String>();
                         var layerNames = new LinkedHashSet<String>();
                         for (var role : topologyVariant.getRoles()) {
                             roleNames.add(role.getName());
                             layerNames.addAll(role.getLayers().getOrElse(List.of()));
                         }
-                    if (!variantArtifact.getSlots().isEmpty()) {
+                        return new TopologyScope(Set.copyOf(roleNames), Set.copyOf(layerNames));
-                        if (variantArtifact.findPrimarySlotName().isEmpty()) {
-                            errors.add("Variant artifact '" + variantArtifact.getName()
-                                    + "' must declare primary slot because it has multiple slots");
-                        } else {
-                            var primarySlotName = variantArtifact.requirePrimarySlotName();
-                            if (variantArtifact.findSlot(primarySlotName).isEmpty()) {
-                                errors.add("Variant artifact '" + variantArtifact.getName()
-                                        + "' declares unknown primary slot '" + primarySlotName + "'");
-                    for (var slot : variantArtifact.getSlots()) {
-                        for (var rule : slot.bindingRules()) {
-                            switch (rule.selector().kind()) {
-                                case VARIANT -> {
-                                case ROLE -> {
-                                    if (!roleNames.contains(rule.selector().value())) {
-                                        errors.add("Variant artifact '" + variantArtifact.getName() + "', slot '" + slot.getName()
-                                                + "' references unknown role '" + rule.selector().value() + "'");
-                                case LAYER -> {
-                                    if (!layerNames.contains(rule.selector().value())) {
-                                        errors.add("Variant artifact '" + variantArtifact.getName() + "', slot '" + slot.getName()
-                                                + "' references unknown layer '" + rule.selector().value() + "'");
                     }
                 }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("variantArtifacts model is finalized and cannot " + operation);
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsPlugin.java ~~common/src/main/java/org/implab/gradle/common/sources/VariantsArtifactsPlugin.java~~ renamed +3 -2

             package org.implab.gradle.common.sources;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.ArrayList;
             import java.util.stream.Collectors;
             import java.util.stream.Stream;
             import org.gradle.api.GradleException;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.artifacts.ConfigurationPublications;
             import org.gradle.api.artifacts.ConfigurationVariant;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
             import org.implab.gradle.common.core.lang.Strings;
-            public abstract class VariantsArtifactsPlugin implements Plugin<Project> {
+            public abstract class VariantArtifactsPlugin implements Plugin<Project> {
-                private static final Logger logger = Logging.getLogger(VariantsArtifactsPlugin.class);
+                private static final Logger logger = Logging.getLogger(VariantArtifactsPlugin.class);
                 public static final String VARIANT_ARTIFACTS_EXTENSION_NAME = "variantArtifacts";
                 @Override
                 public void apply(Project target) {
                     logger.debug("Registering '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
                     target.getPluginManager().apply(VariantsSourcesPlugin.class);
                     var variants = VariantsPlugin.getVariantsExtension(target);
                     var variantSources = target.getExtensions().getByType(VariantSourcesExtension.class);
                     var variantArtifacts = target.getExtensions()
                             .create(VARIANT_ARTIFACTS_EXTENSION_NAME, VariantArtifactsExtension.class);
                     var variantArtifactsResolver = new VariantArtifactsResolver(target.getObjects());
                     var artifactAssemblies = new ArtifactAssemblyRegistry(target.getObjects(), target.getTasks());
+                    // Bind variant artifacts resolution to variant sources registration, so that artifact resolution can be performed
                     variantSources.whenBound(variantArtifactsResolver::recordBinding);
                     variants.whenFinalized(model -> {
                         logger.debug("Finalizing variantArtifacts model on project '{}'", target.getPath());
                         variantArtifacts.finalizeModel(model);
                         materializeOutgoingVariants(target, model, variantArtifacts, variantArtifactsResolver, artifactAssemblies);
                         logger.debug("variantArtifacts model finalized on project '{}'", target.getPath());
                     });
                 }
                 public static VariantArtifactsExtension getVariantArtifactsExtension(Project target) {
                     var extension = target.getExtensions().findByType(VariantArtifactsExtension.class);
                     if (extension == null) {
                         logger.error("variantArtifacts extension '{}' isn't found on project '{}'",
                                 VARIANT_ARTIFACTS_EXTENSION_NAME,
                                 target.getPath());
                         throw new GradleException("variantArtifacts extension isn't found");
                     }
                     logger.debug("Resolved '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
                     return extension;
                 }
                 private static void materializeOutgoingVariants(
                         Project project,
                         BuildVariantsExtension topology,
                         VariantArtifactsExtension variantArtifacts,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies) {
                     variantArtifacts.getVariants().stream()
                             .filter(variantArtifact -> !variantArtifact.getSlots().isEmpty())
                             .forEach(variantArtifact -> materializeOutgoingVariant(
                                     project,
                                     topology.require(variantArtifact.getName()),
                                     variantArtifact,
                                     variantArtifactsResolver,
                                     artifactAssemblies,
                                     variantArtifacts));
                 }
                 private static void materializeOutgoingVariant(
                         Project project,
                         BuildVariant topologyVariant,
                         VariantArtifact variantArtifact,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies,
                         VariantArtifactsExtension variantArtifacts) {
                     var assemblies = variantArtifact.getSlots().stream()
                             .collect(Collectors.toMap(
                                     VariantArtifactSlot::getName,
                                     slot -> registerAssembly(project, variantArtifactsResolver, artifactAssemblies, variantArtifact, slot),
                                     (left, right) -> left,
                                     LinkedHashMap::new));
                     var primarySlot = variantArtifact.requirePrimarySlot();
                     var configuration = createOutgoingConfiguration(project, variantArtifact.getName(), primarySlot.getName());
                     var primaryAssembly = assemblies.get(primarySlot.getName());
                     publishPrimaryArtifact(configuration, primaryAssembly);
                     var primaryPublication = new OutgoingArtifactSlotPublication(
                             primarySlot.getName(),
                             true,
                             primarySlot,
                             primaryAssembly,
                             configuration);
                     var secondarySlots = variantArtifact.getSlots().stream()
                             .filter(slot -> !slot.getName().equals(primarySlot.getName()))
                             .map(slot -> new SecondarySlot(slot, assemblies.get(slot.getName())))
                             .toList();
                     var secondaryPublications = new ArrayList<OutgoingArtifactSlotPublication>(secondarySlots.size());
                     secondarySlots.forEach(secondarySlot -> {
                         var secondaryVariant = configuration.getOutgoing().getVariants().create(secondarySlot.slot().getName());
                         publishSecondaryArtifact(secondaryVariant, secondarySlot.assembly());
                         secondaryPublications.add(new OutgoingArtifactSlotPublication(
                                 secondarySlot.slot().getName(),
                                 false,
                                 secondarySlot.slot(),
                                 secondarySlot.assembly(),
                                 secondaryVariant));
                     });
                     var slotPublications = Stream.concat(
                             Stream.of(primaryPublication),
                             secondaryPublications.stream())
                             .toList();
                     variantArtifacts.notifyOutgoingVariant(new OutgoingVariantPublication(
                             variantArtifact.getName(),
                             topologyVariant,
                             variantArtifact,
                             configuration,
                             primaryPublication,
                             slotPublications));
                 }
                 private static ArtifactAssembly registerAssembly(
                         Project project,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies,
                         VariantArtifact variantArtifact,
                         VariantArtifactSlot slot) {
                     return artifactAssemblies.register(
                             variantArtifact.getName() + Strings.capitalize(slot.getName()),
                             "process" + Strings.capitalize(variantArtifact.getName()) + Strings.capitalize(slot.getName()),
                             project.getLayout().getBuildDirectory()
                                     .dir("variant-artifacts/" + variantArtifact.getName() + "/" + slot.getName()),
                             files -> files.from(variantArtifactsResolver.files(variantArtifact.getName(), slot)));
                 }
                 private static Configuration createOutgoingConfiguration(
                         Project project,
                         String variantName,
                         String primarySlotName) {
                     var configName = variantName + "Elements";
                     return project.getConfigurations().consumable(configName, config -> {
                         config.setVisible(true);
                         config.setDescription("Consumable assembled artifacts for variant '" + variantName
                                 + "' with primary slot '" + primarySlotName + "'");
                     }).get();
                 }
                 private static void publishPrimaryArtifact(Configuration configuration, ArtifactAssembly assembly) {
                     publishArtifact(configuration.getOutgoing(), assembly);
                 }
                 private static void publishSecondaryArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
                     publishArtifact(variant, assembly);
                 }
                 private static void publishArtifact(ConfigurationPublications outgoing, ArtifactAssembly assembly) {
                     outgoing.artifact(assembly.getOutput().getSingleFile(), published -> {
                         published.builtBy(assembly.getOutput().getBuildDependencies());
                     });
                 }
                 private static void publishArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
                     variant.artifact(assembly.getOutput().getSingleFile(), published -> {
                         published.builtBy(assembly.getOutput().getBuildDependencies());
                     });
                 }
                 private record SecondarySlot(VariantArtifactSlot slot, ArtifactAssembly assembly) {
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsResolver.java +87 -24

@@ -1,58 +1,121
1	package org.implab.gradle.common.sources;	1	package org.implab.gradle.common.sources;
2		2
3	import java.util.ArrayList;	3	import java.util.ArrayList;
4	import java.util.LinkedHashSet;	4	import java.util.LinkedHashSet;
5	import java.util.List;	5	import java.util.List;
6	import java.util.Set;	6	import java.util.Set;
7		7
8	import org.eclipse.jdt.annotation.NonNullByDefault;	8	import org.eclipse.jdt.annotation.NonNullByDefault;
9	import org.gradle.api.file.ConfigurableFileCollection;	9	import org.gradle.api.file.ConfigurableFileCollection;
10	import org.gradle.api.file.FileCollection;	10	import org.gradle.api.file.FileCollection;
11	import org.gradle.api.model.ObjectFactory;	11	import org.gradle.api.model.ObjectFactory;
		12	import org.implab.gradle.common.sources.VariantArtifactSlot.BindingKey;
12		13
		14	/**
		15	* Resolves artifact-slot inputs from already bound variant source-set usages.
		16	*
		17	* <p>This type is the bridge between two models:
		18	* <ul>
		19	* <li>{@link VariantSourcesExtension}, which emits resolved
		20	* {@link SourceSetUsageBinding variant/role/layer -> source-set} bindings;</li>
		21	* <li>{@link VariantArtifactSlot}, which exposes a DSL over slot contributions
		22	* and stores the resulting {@link VariantArtifactSlot.BindingResolver
		23	* contribution resolvers}.</li>
		24	* </ul>
		25	*
		26	* <p>The resolver records each emitted {@link SourceSetUsageBinding} and later
		27	* materializes a {@link FileCollection} for one concrete variant/slot pair.
		28	* For each variant/slot pair it asks the slot to materialize its contributions,
		29	* passes in the resolved source-set bindings for that variant, and
		30	* deduplicates resulting inputs by {@link BindingKey}. Contributions that do
		31	* not depend on topology bindings can still emit direct inputs even when that
		32	* binding collection is empty. The returned files are then typically wired into
		33	* an {@link ArtifactAssembly} as its sources.
		34	*
		35	* <p>Direct clients are infrastructure code rather than build scripts. The
		36	* typical usage pattern is:
		37	* <ol>
		38	* <li>create one resolver per project;</li>
		39	* <li>subscribe {@link #recordBinding(SourceSetUsageBinding)} to
		40	* {@link VariantSourcesExtension#whenBound(org.gradle.api.Action)};</li>
		41	* <li>call {@link #files(String, VariantArtifactSlot)} while registering an
		42	* {@link ArtifactAssembly} or another consumer that needs the slot inputs.</li>
		43	* </ol>
		44	*
		45	* <p>Build-script users normally do not instantiate this class directly. They
		46	* configure {@code variantArtifacts}, and {@link VariantArtifactsPlugin} uses
		47	* this resolver internally to turn slot rules into assembly inputs.
		48	*/
13	@NonNullByDefault	49	@NonNullByDefault
14	public final class VariantArtifactsResolver {	50	public final class VariantArtifactsResolver {
15	private final ObjectFactory objects;	51	private final ObjectFactory objects;
16	private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();	52	private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();
17		53
18	public VariantArtifactsResolver(ObjectFactory objects) {	54	public VariantArtifactsResolver(ObjectFactory objects) {
19	this.objects = objects;	55	this.objects = objects;
20	}	56	}
21		57
		58	/**
		59	* Records one resolved variant source-set usage.
		60	*
		61	* <p>Intended to be used as a callback target for
		62	* {@link VariantSourcesExtension#whenBound(org.gradle.api.Action)}.
		63	*
		64	* @param context resolved variant/role/layer usage bound to a source set
		65	*/
22	public void recordBinding(SourceSetUsageBinding context) {	66	public void recordBinding(SourceSetUsageBinding context) {
23	boundContexts.add(context);	67	boundContexts.add(context);
24	}	68	}
25		69
		70	/**
		71	* Returns all source-set outputs selected by the given slot for the given
		72	* variant.
		73	*
		74	* <p>The result is built from recorded {@link SourceSetUsageBinding}
		75	* instances whose {@link SourceSetUsageBinding#variantName()} matches
		76	* {@code variantName}. Each matching binding is then fed into the slot
		77	* contribution pipeline; if multiple contributions resolve to the same
		78	* {@link BindingKey}, that source is included only once.
		79	*
		80	* <p>This method does not validate the model; validation is expected to be
		81	* performed earlier by {@link VariantArtifactsExtension}. Unknown variants
		82	* or slots with no matching rules simply produce an empty collection.
		83	*
		84	* @param variantName variant whose bound source-set usages should be scanned
		85	* @param slot slot definition that selects which outputs should be included
		86	* @return lazily wired file collection for the selected outputs
		87	*/
26	public FileCollection files(String variantName, VariantArtifactSlot slot) {	88	public FileCollection files(String variantName, VariantArtifactSlot slot) {
27	var ~~files~~ = ~~objects~~.fileCollection();	89	var builder = new FileCollectionBuilder();
28	var boundOutputs = new LinkedHashSet<String>();	90	var contexts = boundContexts.stream()
		91	.filter(context -> variantName.equals(context.variantName()))
		92	.toList();
29		93
30	boundContexts.stream()	94	slot.bindings().forEach(binding -> binding.resolve(contexts, builder::addOutput));
31	.filter(context -> variantName.equals(context.variantName()))	95
32	.forEach(context -> bindMatchingOutputs(files, boundOutputs, slot, context));	96	return builder.build();
		97	}
33		98
		99	/**
		100	* Local materialization helper for one {@link #files(String, VariantArtifactSlot)}
		101	* call.
		102	*/
		103	class FileCollectionBuilder {
		104	private final ConfigurableFileCollection files;
		105	private final Set<BindingKey> boundOutputs = new LinkedHashSet<>();
		106
		107	FileCollectionBuilder() {
		108	this.files = objects.fileCollection();
		109	}
		110
		111	FileCollection build() {
34	return files;	112	return files;
35	}	113	}
36		114
37	private static void bindMatchingOutputs(	115	void addOutput(VariantArtifactSlot.ResolvedBinding binding) {
38	ConfigurableFileCollection files,	116	if (boundOutputs.add(binding.key()))
39	Set<String> boundOutputs,	117	files.from(binding.files());
40	VariantArtifactSlot slot,	118	}
41	SourceSetUsageBinding context) {
42	slot.bindingRules().stream()
43	.filter(rule -> rule.matches(context))
44	.forEach(rule -> bindOutput(files, boundOutputs, context, rule.outputName()));
45	}	119	}
46		120
47	private static void bindOutput(
48	ConfigurableFileCollection files,
49	Set<String> boundOutputs,
50	SourceSetUsageBinding context,
51	String outputName) {
52	var key = context.sourceSetName() + "\u0000" + outputName;
53	if (!boundOutputs.add(key))
54	return;
55
56	files.from(context.sourceSet().map(sourceSet -> sourceSet.output(outputName)));
57	}	121	}
58	}

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

	@@ -1,1 +1,1
	1	implementation-class=org.implab.gradle.common.sources.VariantsArtifactsPlugin		1	implementation-class=org.implab.gradle.common.sources.VariantArtifactsPlugin

common/src/test/java/org/implab/gradle/common/sources/VariantsArtifactsPluginFunctionalTest.java +107 -2

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

common/variant-artifacts-plugin.md +48 -5

             # Variant Artifacts Plugin
             ## NAME
             `VariantsArtifactsPlugin` и extension `variantArtifacts`.
             ## SYNOPSIS
             ```groovy
             import org.gradle.api.attributes.Attribute
             plugins {
                 id 'org.implab.gradle-variants-artifacts'
             }
             def variantAttr = Attribute.of('test.variant', String)
             def slotAttr = Attribute.of('test.slot', String)
             variants {
                 layer('main')
                 variant('browser') {
                     role('main') { layers('main') }
                 }
             }
             variantSources {
                 bind('main') {
                     configureSourceSet {
                         declareOutputs('types', 'js', 'resources')
                     }
                 }
             }
             variantArtifacts {
                 variant('browser') {
                     primarySlot('typesPackage') {
                         fromVariant {
                             output('types')
                         }
                     }
                     slot('js') {
                         fromVariant {
                             output('js')
                         }
                     }
                     slot('resources') {
                         fromVariant {
                             output('resources')
                         }
                     }
                 }
                 whenOutgoingVariant { publication ->
                     publication.configureConfiguration {
                         attributes.attribute(variantAttr, publication.variantName())
                     }
                     publication.primarySlot().configureArtifactAttributes {
                         attribute(slotAttr, publication.primarySlot().slotName())
                     }
                     publication.requireSlot('js').configureArtifactAttributes {
                         attribute(slotAttr, 'js')
                     }
                     publication.requireSlot('resources').configureArtifactAttributes {
                         attribute(slotAttr, 'resources')
                     }
                 }
             }
             ```
             ## DESCRIPTION
             `VariantsArtifactsPlugin` применяет `VariantsSourcesPlugin`, затем строит
             outgoing publication model поверх `variantSources`.
             ### publication model
             Для каждого `variantArtifacts.variant('<name>')` публикуется один outgoing
             build variant:
             - primary configuration `<variant>Elements`;
             - primary artifact slot на самой configuration;
             - secondary variants внутри `configuration.outgoing.variants` для остальных slots.
             Пример:
             - `browserElements`
             - primary slot: `typesPackage`
             - secondary variants: `js`, `resources`
             Это разделяет:
             - graph selection build variant-а;
             - artifact selection внутри уже выбранного variant-а.
-            ### slot bindings
+            ### slot contributions и DSL
-            `slot('<name>')` описывает, какие outputs из `variantSources` войдут в artifact
+            `slot('<name>')` описывает artifact representation не как один файл или одну
-            representation этого slot-а.
+            задачу, а как набор contributions, которые потом materialize-ятся в отдельный
+            `ArtifactAssembly`.
-            Binding rules:
+            Текущий DSL поддерживает два вида contributions:
+            - topology-aware:
               - `fromVariant { output(...) }`
               - `fromRole('<role>') { output(...) }`
               - `fromLayer('<layer>') { output(...) }`
+            - direct:
+              - `from(someFileOrProviderOrTaskOutput)`
+            Смысл DSL по слоям:
+            - `fromVariant/fromRole/fromLayer` выбирают область topology model, в которой
+              contribution активен;
+            - `output(...)` выбирает named output соответствующего `GenericSourceSet`;
+            - `from(Object)` добавляет direct contribution, не зависящий от
+              `variantSources` bindings;
+            - итоговый contribution при materialization:
+              - проверяет, подходит ли текущий `SourceSetUsageBinding`;
+              - выдает object для `files.from(...)`;
+              - при необходимости выдает `BindingKey`, если такой contribution должен
+                схлопываться по logical identity.
+            Связь slot-а с остальной моделью:
+            - `variants` задает topology variant/role/layer;
+            - `variantSources` превращает topology в concrete `SourceSetUsageBinding`;
+            - `variantArtifacts.slot(...)` описывает, какие bindings надо включить в slot;
+            - `VariantArtifactsResolver` превращает contributions slot-а в `FileCollection`;
+            - `VariantArtifactsPlugin` регистрирует для slot-а отдельный `ArtifactAssembly`;
+            - `OutgoingVariantPublication` и `OutgoingArtifactSlotPublication` публикуют
+              уже собранные slot artifacts наружу.
             Каждый slot materialize-ится в отдельный `ArtifactAssembly`:
             - task: `process<Variant><Slot>`;
             - output dir: `build/variant-artifacts/<variant>/<slot>`.
             ### primary slot
             Primary slot задает artifact, который публикуется как основной artifact
             configuration `<variant>Elements`.
             Формы DSL:
             ```groovy
             variant('browser') {
                 primarySlot('typesPackage')
                 slot('typesPackage') {
                     fromVariant { output('types') }
                 }
             }
             ```
             или sugar:
             ```groovy
             variant('browser') {
                 primarySlot('typesPackage') {
                     fromVariant { output('types') }
                 }
             }
             ```
             Правила:
             - если slot один, он считается primary неявно;
             - если slots несколько, `primarySlot(...)` обязателен;
             - `primarySlot` должен ссылаться на существующий slot.
             ## LIFECYCLE
             - `VariantsArtifactsPlugin` ждет `variants.whenFinalized(...)`;
             - после этого валидирует `variantArtifacts`;
             - регистрирует `ArtifactAssembly` по каждому slot;
             - materialize-ит outgoing publications;
             - вызывает `whenOutgoingVariant(...)`;
             - callbacks replayable.
             После finalize мутации `variantArtifacts` запрещены.
             ## EVENTS
             ### whenOutgoingVariant
             Replayable callback на готовую outgoing publication variant-а.
             Подходит для:
             - настройки общих attributes build variant-а один раз;
             - настройки per-slot artifact attributes;
             - доконфигурации `ArtifactAssembly`.
             ## PAYLOAD TYPES
             ### OutgoingVariantPublication
             Содержит:
             - `variantName()`;
             - `topologyVariant()`;
             - `variantArtifact()`;
             - `configuration()` — primary `<variant>Elements`;
             - `primarySlot()`;
             - `slots()` — все slot publications;
             - `secondarySlots()`;
             - `findSlot(name)`, `requireSlot(name)`.
             Sugar:
             - `configureConfiguration(Action|Closure)`.
             ### OutgoingArtifactSlotPublication
             Содержит:
             - `slotName()`;
             - `primary()`;
             - `slot()` — модель `VariantArtifactSlot`;
             - `assembly()`.
             Sugar:
             - `configureAssembly(Action|Closure)`;
             - `configureArtifactAttributes(Action|Closure)`.
             `configureArtifactAttributes(...)` пишет attributes:
             - в `Configuration.attributes` для primary slot;
             - в `ConfigurationVariant.attributes` для secondary slot.
             ## CONSUMER SIDE
             ### primary resolution
             Обычное inter-project resolution выбирает primary artifact `<variant>Elements`.
             Пример:
             ```groovy
             configurations {
                 compileView {
                     canBeResolved = true
                     canBeConsumed = false
                     canBeDeclared = true
                     attributes {
                         attribute(variantAttr, 'browser')
                         attribute(slotAttr, 'typesPackage')
                     }
                 }
             }
             dependencies {
                 compileView project(':producer')
             }
             ```
             ### artifact selection for secondary slots
             Secondary artifacts выбираются через `artifactView`.
             ```groovy
             def jsFiles = configurations.compileView.incoming.artifactView {
                 attributes {
                     attribute(slotAttr, 'js')
                 }
             }.files
             ```
             Здесь graph variant уже выбран, а `artifactView` выбирает нужный secondary
             artifact representation.
             ## VALIDATION
             Проверяется:
             - variant существует в topology model;
-            - slot bindings не ссылаются на неизвестные role/layer;
+            - slot contributions не ссылаются на неизвестные role/layer;
             - при нескольких slots указан `primarySlot`;
             - `primarySlot` ссылается на существующий slot.
             ## API
             ### VariantArtifactsExtension
             - `variant(String)` — получить/создать variant artifact model;
             - `variant(String, Action|Closure)` — сконфигурировать variant artifact;
             - `getVariants()` — контейнер variant artifacts;
             - `findVariant(name)`, `requireVariant(name)`;
             - `whenOutgoingVariant(...)`.
             ### VariantArtifact
             - `slot(String)` — получить/создать slot;
             - `slot(String, Action|Closure)` — сконфигурировать slot;
             - `primarySlot(String)` — назначить primary slot;
             - `primarySlot(String, Action|Closure)` — sugar: configure slot + mark as primary;
             - `getSlots()`;
             - `findSlot(name)`, `requireSlot(name)`;
             - `findPrimarySlotName()`, `requirePrimarySlotName()`;
             - `findPrimarySlot()`, `requirePrimarySlot()`.
             ### VariantArtifactSlot
+            - `from(Object)`;
             - `fromVariant(...)`;
             - `fromRole(String, ...)`;
             - `fromLayer(String, ...)`.
+            Внутренняя модель:
+            - slot хранит contributions, а не строковые rules;
+            - `fromVariant/fromRole/fromLayer` создают topology-aware contributions;
+            - `from(Object)` создает direct contribution, который materialize-ится даже
+              если у variant-а нет ни одного `SourceSetUsageBinding`;
+            - slot отдельно хранит topology references для validation:
+              `referencedRoleNames()` и `referencedLayerNames()`.
             ### OutputSelectionSpec
             - `output(name)`;
             - `output(name, extra...)`.
+            `OutputSelectionSpec` это внутренний DSL-buffer для одного блока
+            `fromVariant/fromRole/fromLayer`. Он локально накапливает contributions и
+            передает их в slot только после успешного завершения configure-блока.
             ## KEY CLASSES
             - `VariantsArtifactsPlugin` — plugin adapter и materialization outgoing variants.
             - `VariantArtifactsExtension` — root DSL и lifecycle.
             - `VariantArtifact` — outgoing build variant model.
             - `VariantArtifactSlot` — artifact representation slot.
+            - `VariantArtifactsResolver` — adapter между `variantSources` bindings и
+              contribution model slot-а.
             - `OutgoingVariantPublication` — payload variant-level publication callback.
             - `OutgoingArtifactSlotPublication` — payload per-slot publication callback.
             - `ArtifactAssembly` — assembled files for a slot.
             ## NOTES
             - `common` не навязывает доменную логику выбора primary slot.
             - `common` не фиксирует значения `usage`, `libraryelements` и прочих
               slot-specific attributes.
             - `common` не смешивает эту модель с отдельными publish осями вроде package
               metadata.
             - Closure callbacks используют delegate-first; для вложенных closure удобнее
               явный параметр (`publication -> ...`, `slotPublication -> ...`).

General Comments 0

Write
Preview

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

No TODOs yet

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

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