implab/gradle-common Commit - r33:6f01b47b894d

Added variant artifacts model

cin -

r33:6f01b47b894d default

parent child

Context file:

r33:6f01b47b894d

Collapse all files

common/src/main/java/org/implab/gradle/common/sources/ArtifactAssembly.java created 644 +53 0

@@ -0,0 +1,53
	1	package org.implab.gradle.common.sources;
	2
	3	import org.eclipse.jdt.annotation.NonNullByDefault;
	4	import org.gradle.api.Named;
	5	import org.gradle.api.file.ConfigurableFileCollection;
	6	import org.gradle.api.file.Directory;
	7	import org.gradle.api.file.FileCollection;
	8	import org.gradle.api.provider.Provider;
	9	import org.gradle.api.tasks.Copy;
	10	import org.gradle.api.tasks.TaskProvider;
	11
	12	@NonNullByDefault
	13	public final class ArtifactAssembly implements Named {
	14	private final String name;
	15	private final ConfigurableFileCollection sources;
	16	private final ConfigurableFileCollection output;
	17	private final Provider<Directory> outputDirectory;
	18	private final TaskProvider<Copy> task;
	19
	20	ArtifactAssembly(
	21	String name,
	22	ConfigurableFileCollection sources,
	23	Provider<Directory> outputDirectory,
	24	TaskProvider<Copy> task,
	25	ConfigurableFileCollection output) {
	26	this.name = name;
	27	this.sources = sources;
	28	this.outputDirectory = outputDirectory;
	29	this.task = task;
	30	this.output = output;
	31	}
	32
	33	@Override
	34	public String getName() {
	35	return name;
	36	}
	37
	38	public ConfigurableFileCollection getSources() {
	39	return sources;
	40	}
	41
	42	public FileCollection getOutput() {
	43	return output;
	44	}
	45
	46	public Provider<Directory> getOutputDirectory() {
	47	return outputDirectory;
	48	}
	49
	50	public TaskProvider<Copy> getTask() {
	51	return task;
	52	}
	53	}

common/src/main/java/org/implab/gradle/common/sources/ArtifactAssemblyRegistry.java created 644 +64 0

@@ -0,0 +1,64
	1	package org.implab.gradle.common.sources;
	2
	3	import java.util.LinkedHashMap;
	4	import java.util.Map;
	5	import java.util.Optional;
	6
	7	import org.eclipse.jdt.annotation.NonNullByDefault;
	8	import org.gradle.api.Action;
	9	import org.gradle.api.InvalidUserDataException;
	10	import org.gradle.api.file.ConfigurableFileCollection;
	11	import org.gradle.api.file.Directory;
	12	import org.gradle.api.model.ObjectFactory;
	13	import org.gradle.api.provider.Provider;
	14	import org.gradle.api.tasks.Copy;
	15	import org.gradle.api.tasks.TaskContainer;
	16	import org.gradle.language.base.plugins.LifecycleBasePlugin;
	17
	18	@NonNullByDefault
	19	public final class ArtifactAssemblyRegistry {
	20	private final ObjectFactory objects;
	21	private final TaskContainer tasks;
	22	private final Map<String, ArtifactAssembly> assemblies = new LinkedHashMap<>();
	23
	24	public ArtifactAssemblyRegistry(ObjectFactory objects, TaskContainer tasks) {
	25	this.objects = objects;
	26	this.tasks = tasks;
	27	}
	28
	29	public ArtifactAssembly register(
	30	String name,
	31	String taskName,
	32	Provider<Directory> outputDirectory,
	33	Action<? super ConfigurableFileCollection> configureSources) {
	34	if (assemblies.containsKey(name)) {
	35	throw new InvalidUserDataException("Artifact assembly '" + name + "' is already registered");
	36	}
	37
	38	var sources = objects.fileCollection();
	39	configureSources.execute(sources);
	40
	41	var task = tasks.register(taskName, Copy.class, copy -> {
	42	copy.setGroup(LifecycleBasePlugin.BUILD_GROUP);
	43	copy.into(outputDirectory);
	44	copy.from(sources);
	45	});
	46
	47	var output = objects.fileCollection()
	48	.from(outputDirectory)
	49	.builtBy(task);
	50
	51	var assembly = new ArtifactAssembly(name, sources, outputDirectory, task, output);
	52	assemblies.put(name, assembly);
	53	return assembly;
	54	}
	55
	56	public Optional<ArtifactAssembly> find(String name) {
	57	return Optional.ofNullable(assemblies.get(name));
	58	}
	59
	60	public ArtifactAssembly require(String name) {
	61	return find(name)
	62	.orElseThrow(() -> new InvalidUserDataException("Artifact assembly '" + name + "' isn't registered"));
	63	}
	64	}

common/src/main/java/org/implab/gradle/common/sources/OutgoingVariantPublication.java created 644 +38 0

@@ -0,0 +1,38
	1	package org.implab.gradle.common.sources;
	2
	3	import org.eclipse.jdt.annotation.NonNullByDefault;
	4	import org.implab.gradle.common.core.lang.Closures;
	5	import org.gradle.api.Action;
	6	import org.gradle.api.NamedDomainObjectProvider;
	7	import org.gradle.api.artifacts.Configuration;
	8
	9	import groovy.lang.Closure;
	10	import groovy.lang.DelegatesTo;
	11
	12	@NonNullByDefault
	13	public record OutgoingVariantPublication(
	14	String variantName,
	15	String slotName,
	16	BuildVariant topologyVariant,
	17	VariantArtifact variantArtifact,
	18	VariantArtifactSlot slot,
	19	ArtifactAssembly assembly,
	20	NamedDomainObjectProvider<? extends Configuration> configuration) {
	21	public void configureConfiguration(Action<? super Configuration> action) {
	22	configuration.configure(action);
	23	}
	24
	25	public void configureConfiguration(
	26	@DelegatesTo(value = Configuration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	27	configureConfiguration(Closures.action(action));
	28	}
	29
	30	public void configureAssembly(Action<? super ArtifactAssembly> action) {
	31	action.execute(assembly);
	32	}
	33
	34	public void configureAssembly(
	35	@DelegatesTo(value = ArtifactAssembly.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	36	configureAssembly(Closures.action(action));
	37	}
	38	}

common/src/main/java/org/implab/gradle/common/sources/VariantArtifact.java created 644 +94 0

@@ -0,0 +1,94
	1	package org.implab.gradle.common.sources;
	2
	3	import java.util.Optional;
	4
	5	import javax.inject.Inject;
	6
	7	import org.eclipse.jdt.annotation.NonNullByDefault;
	8	import org.gradle.api.Action;
	9	import org.gradle.api.InvalidUserDataException;
	10	import org.gradle.api.Named;
	11	import org.gradle.api.NamedDomainObjectContainer;
	12	import org.implab.gradle.common.core.lang.Closures;
	13
	14	import groovy.lang.Closure;
	15	import groovy.lang.DelegatesTo;
	16
	17	@NonNullByDefault
	18	public class VariantArtifact implements Named {
	19	private final String name;
	20	private final NamedDomainObjectContainer<VariantArtifactSlot> slots;
	21	private boolean finalized;
	22
	23	@Inject
	24	public VariantArtifact(String name, NamedDomainObjectContainer<VariantArtifactSlot> slots) {
	25	this.name = normalize(name, "variant artifact name must not be null or blank");
	26	this.slots = slots;
	27
	28	slots.all(slot -> {
	29	if (finalized)
	30	throw new InvalidUserDataException(
	31	"Variant artifact '" + this.name + "' is finalized and cannot add slot '" + slot.getName() + "'");
	32	});
	33	}
	34
	35	@Override
	36	public String getName() {
	37	return name;
	38	}
	39
	40	public NamedDomainObjectContainer<VariantArtifactSlot> getSlots() {
	41	return slots;
	42	}
	43
	44	public VariantArtifactSlot slot(String name) {
	45	return slot(name, slot -> {
	46	});
	47	}
	48
	49	public VariantArtifactSlot slot(String name, Action<? super VariantArtifactSlot> configure) {
	50	ensureMutable("configure slots");
	51	var slot = slots.maybeCreate(normalize(name, "slot name must not be null or blank"));
	52	configure.execute(slot);
	53	return slot;
	54	}
	55
	56	public VariantArtifactSlot slot(
	57	String name,
	58	@DelegatesTo(value = VariantArtifactSlot.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
	59	return slot(name, Closures.action(configure));
	60	}
	61
	62	public Optional<VariantArtifactSlot> findSlot(String slotName) {
	63	return Optional.ofNullable(slots.findByName(normalize(slotName, "slot name must not be null or blank")));
	64	}
	65
	66	public VariantArtifactSlot requireSlot(String slotName) {
	67	var normalizedSlotName = normalize(slotName, "slot name must not be null or blank");
	68	return Optional.ofNullable(slots.findByName(normalizedSlotName))
	69	.orElseThrow(() -> new InvalidUserDataException(
	70	"Variant artifact '" + name + "' doesn't declare slot '" + normalizedSlotName + "'"));
	71	}
	72
	73	void finalizeModel() {
	74	if (finalized)
	75	return;
	76
	77	for (var slot : slots)
	78	slot.finalizeModel();
	79
	80	finalized = true;
	81	}
	82
	83	static String normalize(String value, String message) {
	84	return Optional.ofNullable(value)
	85	.map(String::trim)
	86	.filter(trimmed -> !trimmed.isEmpty())
	87	.orElseThrow(() -> new InvalidUserDataException(message));
	88	}
	89
	90	private void ensureMutable(String operation) {
	91	if (finalized)
	92	throw new InvalidUserDataException("Variant artifact '" + name + "' is finalized and cannot " + operation);
	93	}
	94	}

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactSlot.java created 644 +138 0

@@ -0,0 +1,138
	1	package org.implab.gradle.common.sources;
	2
	3	import java.util.ArrayList;
	4	import java.util.List;
	5
	6	import javax.inject.Inject;
	7
	8	import org.eclipse.jdt.annotation.NonNullByDefault;
	9	import org.gradle.api.Action;
	10	import org.gradle.api.InvalidUserDataException;
	11	import org.gradle.api.Named;
	12	import org.implab.gradle.common.core.lang.Closures;
	13
	14	import groovy.lang.Closure;
	15	import groovy.lang.DelegatesTo;
	16
	17	@NonNullByDefault
	18	public class VariantArtifactSlot implements Named {
	19	private final String name;
	20	private final List<BindingRule> rules = new ArrayList<>();
	21	private boolean finalized;
	22
	23	@Inject
	24	public VariantArtifactSlot(String name) {
	25	this.name = VariantArtifact.normalize(name, "slot name must not be null or blank");
	26	}
	27
	28	@Override
	29	public String getName() {
	30	return name;
	31	}
	32
	33	public void fromVariant(Action<? super OutputSelectionSpec> configure) {
	34	addRules(BindingSelector.variant(), configure);
	35	}
	36
	37	public void fromVariant(
	38	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
	39	fromVariant(Closures.action(configure));
	40	}
	41
	42	public void fromRole(String roleName, Action<? super OutputSelectionSpec> configure) {
	43	addRules(BindingSelector.role(VariantArtifact.normalize(roleName, "role name must not be null or blank")),
	44	configure);
	45	}
	46
	47	public void fromRole(
	48	String roleName,
	49	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
	50	fromRole(roleName, Closures.action(configure));
	51	}
	52
	53	public void fromLayer(String layerName, Action<? super OutputSelectionSpec> configure) {
	54	addRules(BindingSelector.layer(VariantArtifact.normalize(layerName, "layer name must not be null or blank")),
	55	configure);
	56	}
	57
	58	public void fromLayer(
	59	String layerName,
	60	@DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
	61	fromLayer(layerName, Closures.action(configure));
	62	}
	63
	64	List<BindingRule> bindingRules() {
	65	return List.copyOf(rules);
	66	}
	67
	68	void finalizeModel() {
	69	finalized = true;
	70	}
	71
	72	private void addRules(BindingSelector selector, Action<? super OutputSelectionSpec> configure) {
	73	ensureMutable("configure sources");
	74
	75	var spec = new OutputSelectionSpec(selector);
	76	configure.execute(spec);
	77	rules.addAll(spec.rules());
	78	}
	79
	80	private void ensureMutable(String operation) {
	81	if (finalized)
	82	throw new InvalidUserDataException("Variant artifact slot '" + name + "' is finalized and cannot " + operation);
	83	}
	84
	85	public final class OutputSelectionSpec {
	86	private final BindingSelector selector;
	87	private final List<BindingRule> rules = new ArrayList<>();
	88
	89	private OutputSelectionSpec(BindingSelector selector) {
	90	this.selector = selector;
	91	}
	92
	93	public void output(String name) {
	94	rules.add(new BindingRule(selector,
	95	VariantArtifact.normalize(name, "output name must not be null or blank")));
	96	}
	97
	98	public void output(String name, String... extra) {
	99	output(name);
	100	for (var item : extra)
	101	output(item);
	102	}
	103
	104	private List<BindingRule> rules() {
	105	return List.copyOf(rules);
	106	}
	107	}
	108
	109	record BindingRule(BindingSelector selector, String outputName) {
	110	boolean matches(SourceSetUsageBinding context) {
	111	return switch (selector.kind()) {
	112	case VARIANT -> true;
	113	case ROLE -> selector.value().equals(context.roleName());
	114	case LAYER -> selector.value().equals(context.layerName());
	115	};
	116	}
	117	}
	118
	119	record BindingSelector(SelectorKind kind, String value) {
	120	static BindingSelector variant() {
	121	return new BindingSelector(SelectorKind.VARIANT, "");
	122	}
	123
	124	static BindingSelector role(String roleName) {
	125	return new BindingSelector(SelectorKind.ROLE, roleName);
	126	}
	127
	128	static BindingSelector layer(String layerName) {
	129	return new BindingSelector(SelectorKind.LAYER, layerName);
	130	}
	131	}
	132
	133	enum SelectorKind {
	134	VARIANT,
	135	ROLE,
	136	LAYER
	137	}
	138	}

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsExtension.java created 644 +169 0

@@ -0,0 +1,169
	1	package org.implab.gradle.common.sources;
	2
	3	import java.util.ArrayList;
	4	import java.util.LinkedHashSet;
	5	import java.util.List;
	6	import java.util.Optional;
	7
	8	import javax.inject.Inject;
	9
	10	import org.eclipse.jdt.annotation.NonNullByDefault;
	11	import org.gradle.api.Action;
	12	import org.gradle.api.InvalidUserDataException;
	13	import org.gradle.api.NamedDomainObjectContainer;
	14	import org.gradle.api.model.ObjectFactory;
	15	import org.implab.gradle.common.core.lang.Closures;
	16
	17	import groovy.lang.Closure;
	18	import groovy.lang.DelegatesTo;
	19
	20	@NonNullByDefault
	21	public abstract class VariantArtifactsExtension {
	22	private final NamedDomainObjectContainer<VariantArtifact> variants;
	23	private final ObjectFactory objects;
	24	private final List<Action<? super OutgoingVariantPublication>> outgoingVariantActions = new ArrayList<>();
	25	private final List<OutgoingVariantPublication> outgoingVariants = new ArrayList<>();
	26	private boolean finalized;
	27
	28	@Inject
	29	public VariantArtifactsExtension(ObjectFactory objects) {
	30	this.objects = objects;
	31	variants = objects.domainObjectContainer(VariantArtifact.class, this::newVariantArtifact);
	32
	33	variants.all(variant -> {
	34	if (finalized)
	35	throw new InvalidUserDataException(
	36	"variantArtifacts model is finalized and cannot add variant '" + variant.getName() + "'");
	37	});
	38	}
	39
	40	public NamedDomainObjectContainer<VariantArtifact> getVariants() {
	41	return variants;
	42	}
	43
	44	public VariantArtifact variant(String name) {
	45	return variant(name, variant -> {
	46	});
	47	}
	48
	49	public VariantArtifact variant(String name, Action<? super VariantArtifact> configure) {
	50	ensureMutable("configure variants");
	51	var variant = variants.maybeCreate(VariantArtifact.normalize(name, "variant name must not be null or blank"));
	52	configure.execute(variant);
	53	return variant;
	54	}
	55
	56	public VariantArtifact variant(
	57	String name,
	58	@DelegatesTo(value = VariantArtifact.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
	59	return variant(name, Closures.action(configure));
	60	}
	61
	62	public Optional<VariantArtifact> findVariant(String variantName) {
	63	return Optional
	64	.ofNullable(variants.findByName(VariantArtifact.normalize(variantName, "variant name must not be null or blank")));
	65	}
	66
	67	public VariantArtifact requireVariant(String variantName) {
	68	var normalizedVariantName = VariantArtifact.normalize(variantName, "variant name must not be null or blank");
	69	return findVariant(normalizedVariantName)
	70	.orElseThrow(() -> new InvalidUserDataException(
	71	"Variant artifacts do not declare variant '" + normalizedVariantName + "'"));
	72	}
	73
	74	public void whenOutgoingVariant(Action<? super OutgoingVariantPublication> action) {
	75	outgoingVariantActions.add(action);
	76	for (var publication : outgoingVariants)
	77	action.execute(publication);
	78	}
	79
	80	public void whenOutgoingVariant(
	81	@DelegatesTo(value = OutgoingVariantPublication.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	82	whenOutgoingVariant(Closures.action(action));
	83	}
	84
	85	public boolean isFinalized() {
	86	return finalized;
	87	}
	88
	89	void finalizeModel(BuildVariantsExtension topology) {
	90	if (finalized)
	91	return;
	92
	93	validate(topology);
	94
	95	for (var variant : variants)
	96	variant.finalizeModel();
	97
	98	finalized = true;
	99	}
	100
	101	void notifyOutgoingVariant(OutgoingVariantPublication publication) {
	102	outgoingVariants.add(publication);
	103	for (var action : outgoingVariantActions)
	104	action.execute(publication);
	105	}
	106
	107	private VariantArtifact newVariantArtifact(String name) {
	108	return objects.newInstance(VariantArtifact.class, name, objects.domainObjectContainer(VariantArtifactSlot.class));
	109	}
	110
	111	private void validate(BuildVariantsExtension topology) {
	112	var errors = new ArrayList<String>();
	113
	114	for (var variantArtifact : variants) {
	115	var topologyVariant = topology.find(variantArtifact.getName());
	116	if (topologyVariant.isEmpty()) {
	117	errors.add("Variant artifact '" + variantArtifact.getName() + "' references unknown variant '"
	118	+ variantArtifact.getName() + "'");
	119	continue;
	120	}
	121
	122	validateVariantArtifact(variantArtifact, topologyVariant.get(), errors);
	123	}
	124
	125	if (!errors.isEmpty()) {
	126	var message = new StringBuilder("Invalid variantArtifacts model:");
	127	for (var error : errors)
	128	message.append("\n - ").append(error);
	129
	130	throw new InvalidUserDataException(message.toString());
	131	}
	132	}
	133
	134	private static void validateVariantArtifact(VariantArtifact variantArtifact, BuildVariant topologyVariant, List<String> errors) {
	135	var roleNames = new LinkedHashSet<String>();
	136	var layerNames = new LinkedHashSet<String>();
	137
	138	for (var role : topologyVariant.getRoles()) {
	139	roleNames.add(role.getName());
	140	layerNames.addAll(role.getLayers().getOrElse(List.of()));
	141	}
	142
	143	for (var slot : variantArtifact.getSlots()) {
	144	for (var rule : slot.bindingRules()) {
	145	switch (rule.selector().kind()) {
	146	case VARIANT -> {
	147	}
	148	case ROLE -> {
	149	if (!roleNames.contains(rule.selector().value())) {
	150	errors.add("Variant artifact '" + variantArtifact.getName() + "', slot '" + slot.getName()
	151	+ "' references unknown role '" + rule.selector().value() + "'");
	152	}
	153	}
	154	case LAYER -> {
	155	if (!layerNames.contains(rule.selector().value())) {
	156	errors.add("Variant artifact '" + variantArtifact.getName() + "', slot '" + slot.getName()
	157	+ "' references unknown layer '" + rule.selector().value() + "'");
	158	}
	159	}
	160	}
	161	}
	162	}
	163	}
	164
	165	private void ensureMutable(String operation) {
	166	if (finalized)
	167	throw new InvalidUserDataException("variantArtifacts model is finalized and cannot " + operation);
	168	}
	169	}

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsResolver.java created 644 +58 0

@@ -0,0 +1,58
	1	package org.implab.gradle.common.sources;
	2
	3	import java.util.ArrayList;
	4	import java.util.LinkedHashSet;
	5	import java.util.List;
	6	import java.util.Set;
	7
	8	import org.eclipse.jdt.annotation.NonNullByDefault;
	9	import org.gradle.api.file.ConfigurableFileCollection;
	10	import org.gradle.api.file.FileCollection;
	11	import org.gradle.api.model.ObjectFactory;
	12
	13	@NonNullByDefault
	14	public final class VariantArtifactsResolver {
	15	private final ObjectFactory objects;
	16	private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();
	17
	18	public VariantArtifactsResolver(ObjectFactory objects) {
	19	this.objects = objects;
	20	}
	21
	22	public void recordBinding(SourceSetUsageBinding context) {
	23	boundContexts.add(context);
	24	}
	25
	26	public FileCollection files(String variantName, VariantArtifactSlot slot) {
	27	var files = objects.fileCollection();
	28	var boundOutputs = new LinkedHashSet<String>();
	29
	30	boundContexts.stream()
	31	.filter(context -> variantName.equals(context.variantName()))
	32	.forEach(context -> bindMatchingOutputs(files, boundOutputs, slot, context));
	33
	34	return files;
	35	}
	36
	37	private static void bindMatchingOutputs(
	38	ConfigurableFileCollection files,
	39	Set<String> boundOutputs,
	40	VariantArtifactSlot slot,
	41	SourceSetUsageBinding context) {
	42	slot.bindingRules().stream()
	43	.filter(rule -> rule.matches(context))
	44	.forEach(rule -> bindOutput(files, boundOutputs, context, rule.outputName()));
	45	}
	46
	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	}
	58	}

common/src/main/java/org/implab/gradle/common/sources/VariantsArtifactsPlugin.java created 644 +96 0

@@ -0,0 +1,96
	1	package org.implab.gradle.common.sources;
	2
	3	import org.gradle.api.GradleException;
	4	import org.gradle.api.Plugin;
	5	import org.gradle.api.Project;
	6	import org.gradle.api.artifacts.Configuration;
	7	import org.gradle.api.logging.Logger;
	8	import org.gradle.api.logging.Logging;
	9	import org.implab.gradle.common.core.lang.Strings;
	10
	11	public abstract class VariantsArtifactsPlugin implements Plugin<Project> {
	12	private static final Logger logger = Logging.getLogger(VariantsArtifactsPlugin.class);
	13	public static final String VARIANT_ARTIFACTS_EXTENSION_NAME = "variantArtifacts";
	14
	15	@Override
	16	public void apply(Project target) {
	17	logger.debug("Registering '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
	18
	19	target.getPluginManager().apply(VariantsSourcesPlugin.class);
	20
	21	var variants = VariantsPlugin.getVariantsExtension(target);
	22	var variantSources = target.getExtensions().getByType(VariantSourcesExtension.class);
	23	var variantArtifacts = target.getExtensions()
	24	.create(VARIANT_ARTIFACTS_EXTENSION_NAME, VariantArtifactsExtension.class);
	25	var variantArtifactsResolver = new VariantArtifactsResolver(target.getObjects());
	26	var artifactAssemblies = new ArtifactAssemblyRegistry(target.getObjects(), target.getTasks());
	27
	28	variantSources.whenBound(variantArtifactsResolver::recordBinding);
	29
	30	variants.whenFinalized(model -> {
	31	logger.debug("Finalizing variantArtifacts model on project '{}'", target.getPath());
	32	variantArtifacts.finalizeModel(model);
	33	materializeOutgoingVariants(target, model, variantArtifacts, variantArtifactsResolver, artifactAssemblies);
	34	logger.debug("variantArtifacts model finalized on project '{}'", target.getPath());
	35	});
	36	}
	37
	38	public static VariantArtifactsExtension getVariantArtifactsExtension(Project target) {
	39	var extension = target.getExtensions().findByType(VariantArtifactsExtension.class);
	40
	41	if (extension == null) {
	42	logger.error("variantArtifacts extension '{}' isn't found on project '{}'",
	43	VARIANT_ARTIFACTS_EXTENSION_NAME,
	44	target.getPath());
	45	throw new GradleException("variantArtifacts extension isn't found");
	46	}
	47
	48	logger.debug("Resolved '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
	49
	50	return extension;
	51	}
	52
	53	private static void materializeOutgoingVariants(
	54	Project project,
	55	BuildVariantsExtension topology,
	56	VariantArtifactsExtension variantArtifacts,
	57	VariantArtifactsResolver variantArtifactsResolver,
	58	ArtifactAssemblyRegistry artifactAssemblies) {
	59	for (var variantArtifact : variantArtifacts.getVariants()) {
	60	var topologyVariant = topology.require(variantArtifact.getName());
	61	for (var slot : variantArtifact.getSlots()) {
	62	var assembly = artifactAssemblies.register(
	63	variantArtifact.getName() + Strings.capitalize(slot.getName()),
	64	"process" + Strings.capitalize(variantArtifact.getName()) + Strings.capitalize(slot.getName()),
	65	project.getLayout().getBuildDirectory()
	66	.dir("variant-artifacts/" + variantArtifact.getName() + "/" + slot.getName()),
	67	files -> files.from(variantArtifactsResolver.files(variantArtifact.getName(), slot)));
	68	var configuration = createOutgoingConfiguration(project, variantArtifact.getName(), slot.getName(), assembly);
	69
	70	variantArtifacts.notifyOutgoingVariant(new OutgoingVariantPublication(
	71	variantArtifact.getName(),
	72	slot.getName(),
	73	topologyVariant,
	74	variantArtifact,
	75	slot,
	76	assembly,
	77	configuration));
	78	}
	79	}
	80	}
	81
	82	private static org.gradle.api.NamedDomainObjectProvider<? extends Configuration> createOutgoingConfiguration(
	83	Project project,
	84	String variantName,
	85	String slotName,
	86	ArtifactAssembly assembly) {
	87	var configName = variantName + Strings.capitalize(slotName) + "Elements";
	88	return project.getConfigurations().consumable(configName, config -> {
	89	config.setVisible(true);
	90	config.setDescription("Consumable assembled artifacts for variant '" + variantName + "', slot '" + slotName + "'");
	91	config.getOutgoing().artifact(assembly.getOutput().getSingleFile(), published -> {
	92	published.builtBy(assembly.getOutput().getBuildDependencies());
	93	});
	94	});
	95	}
	96	}

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

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

common/src/test/java/org/implab/gradle/common/sources/VariantsArtifactsPluginFunctionalTest.java created 644 +294 0

@@ -0,0 +1,294
	1	package org.implab.gradle.common.sources;
	2
	3	import static org.junit.jupiter.api.Assertions.assertNotNull;
	4	import static org.junit.jupiter.api.Assertions.assertThrows;
	5	import static org.junit.jupiter.api.Assertions.assertTrue;
	6
	7	import java.io.File;
	8	import java.io.IOException;
	9	import java.nio.file.Files;
	10	import java.nio.file.Path;
	11	import java.util.List;
	12
	13	import org.gradle.testkit.runner.BuildResult;
	14	import org.gradle.testkit.runner.GradleRunner;
	15	import org.gradle.testkit.runner.TaskOutcome;
	16	import org.gradle.testkit.runner.UnexpectedBuildFailure;
	17	import org.junit.jupiter.api.Test;
	18	import org.junit.jupiter.api.io.TempDir;
	19
	20	class VariantsArtifactsPluginFunctionalTest {
	21	private static final String SETTINGS_FILE = "settings.gradle";
	22	private static final String BUILD_FILE = "build.gradle";
	23	private static final String ROOT_NAME = "rootProject.name = 'variants-artifacts-fixture'\n";
	24
	25	@TempDir
	26	Path testProjectDir;
	27
	28	@Test
	29	void materializesVariantArtifactsAndInvokesOutgoingHooks() throws Exception {
	30	writeFile(SETTINGS_FILE, ROOT_NAME);
	31	writeFile("inputs/base.js", "console.log('base')\n");
	32	writeFile("inputs/amd.js", "console.log('amd')\n");
	33	writeFile("inputs/mainJs.txt", "mainJs marker\n");
	34	writeFile("inputs/amdJs.txt", "amdJs marker\n");
	35	writeFile(BUILD_FILE, """
	36	import org.gradle.api.attributes.Attribute
	37
	38	plugins {
	39	id 'org.implab.gradle-variants-artifacts'
	40	}
	41
	42	variants {
	43	layer('mainBase')
	44	layer('mainAmd')
	45
	46	variant('browser') {
	47	role('main') {
	48	layers('mainBase', 'mainAmd')
	49	}
	50	}
	51	}
	52
	53	variantSources {
	54	bind('mainBase') {
	55	configureSourceSet {
	56	declareOutputs('js')
	57	}
	58	}
	59
	60	bind('mainAmd') {
	61	configureSourceSet {
	62	declareOutputs('js')
	63	}
	64	}
	65
	66	whenBound { ctx ->
	67	if (ctx.sourceSetName() == 'browserMainBase') {
	68	ctx.configureSourceSet {
	69	registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
	70	}
	71	}
	72
	73	if (ctx.sourceSetName() == 'browserMainAmd') {
	74	ctx.configureSourceSet {
	75	registerOutput('js', layout.projectDirectory.file('inputs/amd.js'))
	76	}
	77	}
	78	}
	79	}
	80
	81	variantArtifacts {
	82	variant('browser') {
	83	slot('mainJs') {
	84	fromRole('main') {
	85	output('js')
	86	}
	87	}
	88
	89	slot('amdJs') {
	90	fromLayer('mainAmd') {
	91	output('js')
	92	}
	93	}
	94	}
	95
	96	whenOutgoingVariant { publication ->
	97	publication.configureAssembly {
	98	sources.from(layout.projectDirectory.file("inputs/${publication.slotName()}.txt"))
	99	}
	100
	101	publication.configureConfiguration {
	102	attributes.attribute(Attribute.of('test.slot', String), publication.slotName())
	103	}
	104	}
	105	}
	106
	107	tasks.register('probe') {
	108	dependsOn 'processBrowserMainJs', 'processBrowserAmdJs'
	109
	110	doLast {
	111	def mainDir = layout.buildDirectory.dir('variant-artifacts/browser/mainJs').get().asFile
	112	def amdDir = layout.buildDirectory.dir('variant-artifacts/browser/amdJs').get().asFile
	113
	114	assert new File(mainDir, 'base.js').exists()
	115	assert new File(mainDir, 'amd.js').exists()
	116	assert new File(mainDir, 'mainJs.txt').exists()
	117
	118	assert !new File(amdDir, 'base.js').exists()
	119	assert new File(amdDir, 'amd.js').exists()
	120	assert new File(amdDir, 'amdJs.txt').exists()
	121
	122	def mainElements = configurations.getByName('browserMainJsElements')
	123	def attr = mainElements.attributes.getAttribute(Attribute.of('test.slot', String))
	124
	125	println('mainAttr=' + attr)
	126	println('configurations=' + [mainElements.name, configurations.getByName('browserAmdJsElements').name].sort().join(','))
	127	}
	128	}
	129	""");
	130
	131	BuildResult result = runner("probe").build();
	132
	133	assertTrue(result.getOutput().contains("mainAttr=mainJs"));
	134	assertTrue(result.getOutput().contains("configurations=browserAmdJsElements,browserMainJsElements"));
	135	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
	136	}
	137
	138	@Test
	139	void failsOnUnknownVariantReference() throws Exception {
	140	assertBuildFails("""
	141	plugins {
	142	id 'org.implab.gradle-variants-artifacts'
	143	}
	144
	145	variants {
	146	layer('main')
	147	}
	148
	149	variantArtifacts {
	150	variant('browser') {
	151	slot('mainJs') {
	152	fromVariant {
	153	output('js')
	154	}
	155	}
	156	}
	157	}
	158	""", "Variant artifact 'browser' references unknown variant 'browser'");
	159	}
	160
	161	@Test
	162	void failsOnUnknownRoleReference() throws Exception {
	163	assertBuildFails("""
	164	plugins {
	165	id 'org.implab.gradle-variants-artifacts'
	166	}
	167
	168	variants {
	169	layer('main')
	170
	171	variant('browser') {
	172	role('main') {
	173	layers('main')
	174	}
	175	}
	176	}
	177
	178	variantArtifacts {
	179	variant('browser') {
	180	slot('mainJs') {
	181	fromRole('test') {
	182	output('js')
	183	}
	184	}
	185	}
	186	}
	187	""", "Variant artifact 'browser', slot 'mainJs' references unknown role 'test'");
	188	}
	189
	190	@Test
	191	void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
	192	assertBuildFails("""
	193	plugins {
	194	id 'org.implab.gradle-variants-artifacts'
	195	}
	196
	197	variants {
	198	layer('mainBase')
	199	layer('extra')
	200
	201	variant('browser') {
	202	role('main') {
	203	layers('mainBase')
	204	}
	205	}
	206	}
	207
	208	variantArtifacts {
	209	variant('browser') {
	210	slot('extraJs') {
	211	fromLayer('extra') {
	212	output('js')
	213	}
	214	}
	215	}
	216	}
	217	""", "Variant artifact 'browser', slot 'extraJs' references unknown layer 'extra'");
	218	}
	219
	220	@Test
	221	void failsOnLateMutationAfterFinalize() throws Exception {
	222	assertBuildFails("""
	223	plugins {
	224	id 'org.implab.gradle-variants-artifacts'
	225	}
	226
	227	variants {
	228	layer('main')
	229
	230	variant('browser') {
	231	role('main') {
	232	layers('main')
	233	}
	234	}
	235	}
	236
	237	afterEvaluate {
	238	variantArtifacts.variant('late') {
	239	slot('js') {
	240	fromVariant {
	241	output('js')
	242	}
	243	}
	244	}
	245	}
	246	""", "variantArtifacts model is finalized and cannot configure variants");
	247	}
	248
	249	private GradleRunner runner(String... arguments) {
	250	return GradleRunner.create()
	251	.withProjectDir(testProjectDir.toFile())
	252	.withPluginClasspath(pluginClasspath())
	253	.withArguments(arguments)
	254	.forwardOutput();
	255	}
	256
	257	private void assertBuildFails(String buildScript, String expectedError) throws Exception {
	258	writeFile(SETTINGS_FILE, ROOT_NAME);
	259	writeFile(BUILD_FILE, buildScript);
	260
	261	var ex = assertThrows(UnexpectedBuildFailure.class, () -> runner("help").build());
	262	var output = ex.getBuildResult().getOutput();
	263
	264	assertTrue(output.contains(expectedError), () -> "Expected [" + expectedError + "] in output:\n" + output);
	265	}
	266
	267	private static List<File> pluginClasspath() {
	268	try {
	269	var classesDir = Path.of(VariantsArtifactsPlugin.class
	270	.getProtectionDomain()
	271	.getCodeSource()
	272	.getLocation()
	273	.toURI());
	274
	275	var markerResource = VariantsArtifactsPlugin.class.getClassLoader()
	276	.getResource("META-INF/gradle-plugins/org.implab.gradle-variants-artifacts.properties");
	277
	278	assertNotNull(markerResource, "Plugin marker resource is missing from test classpath");
	279
	280	var markerPath = Path.of(markerResource.toURI());
	281	var resourcesDir = markerPath.getParent().getParent().getParent();
	282
	283	return List.of(classesDir.toFile(), resourcesDir.toFile());
	284	} catch (Exception e) {
	285	throw new RuntimeException("Unable to build plugin classpath for test", e);
	286	}
	287	}
	288
	289	private void writeFile(String relativePath, String content) throws IOException {
	290	Path path = testProjectDir.resolve(relativePath);
	291	Files.createDirectories(path.getParent());
	292	Files.writeString(path, content);
	293	}
	294	}

common/src/main/java/org/implab/gradle/common/sources/BuildVariant.java +1 -150

@@ -12,9 +12,6 import org.gradle.api.Action;
12	import org.gradle.api.InvalidUserDataException;	12	import org.gradle.api.InvalidUserDataException;
13	import org.gradle.api.Named;	13	import org.gradle.api.Named;
14	import org.gradle.api.model.ObjectFactory;	14	import org.gradle.api.model.ObjectFactory;
15	import org.gradle.api.provider.Provider;
16	import org.gradle.api.provider.ProviderFactory;
17	import org.gradle.api.attributes.Attribute;
18		15
19	import groovy.lang.Closure;	16	import groovy.lang.Closure;
20		17
@@ -23,18 +20,12 public abstract class BuildVariant imple
23	private final ObjectFactory objects;	20	private final ObjectFactory objects;
24	private boolean finalized;	21	private boolean finalized;
25		22
26	/**
27	* Variant aggregate parts.
28	*/
29	private final VariantAttributes attributes;
30	private final LinkedHashMap<String, BuildRole> roles = new LinkedHashMap<>();	23	private final LinkedHashMap<String, BuildRole> roles = new LinkedHashMap<>();
31	private final LinkedHashMap<String, BuildArtifactSlot> artifactSlots = new LinkedHashMap<>();
32		24
33	@Inject	25	@Inject
34	public BuildVariant(String name, ObjectFactory objects, ~~ProviderFactory~~ ~~providers~~) {	26	public BuildVariant(String name, ObjectFactory objects) {
35	this.name = name;	27	this.name = name;
36	this.objects = objects;	28	this.objects = objects;
37	attributes = new VariantAttributes(providers);
38	}	29	}
39		30
40	@Override	31	@Override
@@ -42,32 +33,6 public abstract class BuildVariant imple
42	return name;	33	return name;
43	}	34	}
44		35
45	/**
46	* Generic variant attributes interpreted by adapters.
47	*/
48	public VariantAttributes getAttributes() {
49	return attributes;
50	}
51
52	public void attributes(Action<? super AttributesSpec> action) {
53	ensureMutable("configure attributes");
54	action.execute(new AttributesSpec(attributes));
55	}
56
57	public void attributes(Closure<?> configure) {
58	attributes(Closures.action(configure));
59	}
60
61	public <T> void attribute(Attribute<T> key, T value) {
62	ensureMutable("set attributes");
63	attributes.attribute(key, value);
64	}
65
66	public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
67	ensureMutable("set attributes");
68	attributes.attributeProvider(key, value);
69	}
70
71	public Collection<BuildRole> getRoles() {	36	public Collection<BuildRole> getRoles() {
72	return Collections.unmodifiableCollection(roles.values());	37	return Collections.unmodifiableCollection(roles.values());
73	}	38	}
@@ -107,45 +72,6 public abstract class BuildVariant imple
107	"Variant '" + this.name + "' doesn't define role '" + name + "'"));	72	"Variant '" + this.name + "' doesn't define role '" + name + "'"));
108	}	73	}
109		74
110	public Collection<BuildArtifactSlot> getArtifactSlots() {
111	return Collections.unmodifiableCollection(artifactSlots.values());
112	}
113
114	public void artifactSlots(Action<? super ArtifactSlotsSpec> action) {
115	ensureMutable("configure artifact slots");
116	action.execute(new ArtifactSlotsSpec());
117	}
118
119	public void artifactSlots(Closure<?> configure) {
120	artifactSlots(Closures.action(configure));
121	}
122
123	public BuildArtifactSlot artifactSlot(String name) {
124	return artifactSlot(name, it -> {
125	});
126	}
127
128	public BuildArtifactSlot artifactSlot(String name, Action<? super BuildArtifactSlot> configure) {
129	ensureMutable("configure artifact slots");
130	var slot = artifactSlots.computeIfAbsent(name, this::newArtifactSlot);
131	configure.execute(slot);
132	return slot;
133	}
134
135	public BuildArtifactSlot artifactSlot(String name, Closure<?> configure) {
136	return artifactSlot(name, Closures.action(configure));
137	}
138
139	public Optional<BuildArtifactSlot> findArtifactSlot(String name) {
140	return Optional.ofNullable(artifactSlots.get(name));
141	}
142
143	public BuildArtifactSlot requireArtifactSlot(String name) {
144	return findArtifactSlot(name)
145	.orElseThrow(() -> new InvalidUserDataException(
146	"Variant '" + this.name + "' doesn't define artifact slot '" + name + "'"));
147	}
148
149	void finalizeModel() {	75	void finalizeModel() {
150	if (finalized)	76	if (finalized)
151	return;	77	return;
@@ -153,7 +79,6 public abstract class BuildVariant imple
153	for (var role : roles.values())	79	for (var role : roles.values())
154	role.finalizeModel();	80	role.finalizeModel();
155		81
156	attributes.finalizeModel();
157	finalized = true;	82	finalized = true;
158	}	83	}
159		84
@@ -161,10 +86,6 public abstract class BuildVariant imple
161	return objects.newInstance(BuildRole.class, roleName);	86	return objects.newInstance(BuildRole.class, roleName);
162	}	87	}
163		88
164	private BuildArtifactSlot newArtifactSlot(String slotName) {
165	return objects.newInstance(BuildArtifactSlot.class, slotName);
166	}
167
168	private void ensureMutable(String operation) {	89	private void ensureMutable(String operation) {
169	if (finalized)	90	if (finalized)
170	throw new InvalidUserDataException("Variant '" + name + "' is finalized and cannot " + operation);	91	throw new InvalidUserDataException("Variant '" + name + "' is finalized and cannot " + operation);
@@ -195,74 +116,4 public abstract class BuildVariant imple
195	return BuildVariant.this.requireRole(name);	116	return BuildVariant.this.requireRole(name);
196	}	117	}
197	}	118	}
198
199	public final class ArtifactSlotsSpec {
200	public BuildArtifactSlot artifactSlot(String name, Action<? super BuildArtifactSlot> configure) {
201	return BuildVariant.this.artifactSlot(name, configure);
202	}	119	}
203
204	public BuildArtifactSlot artifactSlot(String name, Closure<?> configure) {
205	return BuildVariant.this.artifactSlot(name, configure);
206	}
207
208	public BuildArtifactSlot artifactSlot(String name) {
209	return BuildVariant.this.artifactSlot(name);
210	}
211
212	public Collection<BuildArtifactSlot> getAll() {
213	return BuildVariant.this.getArtifactSlots();
214	}
215
216	public Optional<BuildArtifactSlot> find(String name) {
217	return BuildVariant.this.findArtifactSlot(name);
218	}
219
220	public BuildArtifactSlot require(String name) {
221	return BuildVariant.this.requireArtifactSlot(name);
222	}
223	}
224
225	public static final class AttributesSpec {
226	private final VariantAttributes attributes;
227
228	AttributesSpec(VariantAttributes attributes) {
229	this.attributes = attributes;
230	}
231
232	public <T> void attribute(Attribute<T> key, T value) {
233	attributes.attribute(key, value);
234	}
235
236	public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
237	attributes.attributeProvider(key, value);
238	}
239
240	public void string(String name, String value) {
241	attribute(Attribute.of(name, String.class), value);
242	}
243
244	public void string(String name, Provider<? extends String> value) {
245	attributeProvider(Attribute.of(name, String.class), value);
246	}
247
248	public void bool(String name, boolean value) {
249	attribute(Attribute.of(name, Boolean.class), value);
250	}
251
252	public void bool(String name, Provider<? extends Boolean> value) {
253	attributeProvider(Attribute.of(name, Boolean.class), value);
254	}
255
256	public void integer(String name, int value) {
257	attribute(Attribute.of(name, Integer.class), value);
258	}
259
260	public void integer(String name, Provider<? extends Integer> value) {
261	attributeProvider(Attribute.of(name, Integer.class), value);
262	}
263
264	public VariantAttributes asAttributes() {
265	return attributes;
266	}
267	}
268	}

common/src/main/java/org/implab/gradle/common/sources/BuildVariantsExtension.java +2 -14

                         return;
                     }
-                    validateRoleAndArtifactNames(variant, errors);
+                    validateRoleNames(variant, errors);
                     validateRoleMappings(variant, layersByName, errors);
                 }
-                private static void validateRoleAndArtifactNames(BuildVariant variant, List<String> errors) {
+                private static void validateRoleNames(BuildVariant variant, List<String> errors) {
                     var roleNames = new LinkedHashSet<String>();
                     for (var role : variant.getRoles()) {
                         var roleName = normalize(role.getName());
                             errors.add("Variant '" + variant.getName() + "' contains duplicated role name '" + roleName + "'");
                         }
                     }
-                    var slotNames = new LinkedHashSet<String>();
-                    for (var slot : variant.getArtifactSlots()) {
-                        var slotName = normalize(slot.getName());
-                        if (slotName == null) {
-                            errors.add("Variant '" + variant.getName() + "' contains blank artifact slot name");
-                            continue;
-                        if (!slotNames.add(slotName)) {
-                            errors.add("Variant '" + variant.getName() + "' contains duplicated artifact slot name '" + slotName + "'");
                 }
                 private static void validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,

common/src/main/java/org/implab/gradle/common/sources/VariantSourcesExtension.java +15 -4

             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
+            import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
                 private static final Logger logger = Logging.getLogger(VariantSourcesExtension.class);
                 private static final Pattern SOURCE_SET_NAME_TOKEN = Pattern.compile("\\{([A-Za-z][A-Za-z0-9]*)\\}");
+                private final ProjectLayout layout;
                 private final NamedDomainObjectContainer<BuildLayerBinding> bindings;
                 private final List<Action<? super SourceSetRegistration>> registeredActions = new ArrayList<>();
                 private final List<Action<? super SourceSetUsageBinding>> boundActions = new ArrayList<>();
                 private boolean sourceSetsRegistered;
                 @Inject
-                public VariantSourcesExtension(ObjectFactory objects) {
+                public VariantSourcesExtension(ObjectFactory objects, ProjectLayout layout) {
+                    this.layout = layout;
                     bindings = objects.domainObjectContainer(BuildLayerBinding.class);
                 }
                                             .map(layerName -> new LayerUsage(
                                                     variant.getName(),
                                                     role.getName(),
-                                                    normalize(layerName, "Layer name in variant '" + variant.getName() + "' and role '" + role.getName() + "' must not be null or blank")))));
+                                                    normalize(layerName, "Layer name in variant '" + variant.getName()
+                                                            + "' and role '" + role.getName() + "' must not be null or blank")))));
                 }
                 private void registerLayerUsage(LayerUsage usage, NamedDomainObjectContainer<GenericSourceSet> sources) {
                     ensureSourceSetNameBoundToSingleLayer(sourceSetName, usage.layerName());
                     var isNewSourceSet = !sourceSetsByName.containsKey(sourceSetName);
                     var sourceSet = sourceSetsByName.computeIfAbsent(sourceSetName,
-                            name -> sources.register(name));
+                            name -> {
+                                var ssp = sources.register(name);
+                                ssp.configure(x -> {
+                                    x.getSourceSetDir().set(layout.getProjectDirectory().dir("src/" + usage.layerName()));
+                                });
+                                return ssp;
+                            });
                     var binding = new SourceSetUsageBinding(
                             usage.variantName(),
                     var result = sanitizeName(resolved);
                     if (result.isEmpty())
-                        throw new InvalidUserDataException("sourceSetNamePattern '" + pattern + "' resolved to empty source set name");
+                        throw new InvalidUserDataException(
+                                "sourceSetNamePattern '" + pattern + "' resolved to empty source set name");
                     return result;
                 }

common/src/main/java/org/implab/gradle/common/sources/package-info.java +2 -1

             /**
-             * Source model and DSL for variants/sources integration.
+             * Source model and DSL for variant topology, source bindings, artifact assembly
+             * and outgoing publication integration.
              *
              * <p>Naming convention for callbacks and lifecycle hooks:
              * <ul>

common/src/test/java/org/implab/gradle/common/sources/VariantsPluginFunctionalTest.java +2 -9

                             }
                             variant('browser') {
-                                attributes {
-                                    string('jsRuntime', 'browser')
-                                    string('jsModule', 'amd')
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
-                                artifactSlot('mainCompiled')
                             }
                         }
                             tasks.register('probe') {
                                 doLast {
                                 def browser = variants.require('browser')
-                                println('attributes=' + browser.attributes.size())
                                 println('roles=' + browser.roles.size())
-                                println('slots=' + browser.artifactSlots.size())
+                                println('roleLayers=' + browser.requireRole('main').layers.get().join(','))
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
-                    assertTrue(result.getOutput().contains("attributes=2"));
                     assertTrue(result.getOutput().contains("roles=1"));
-                    assertTrue(result.getOutput().contains("slots=1"));
+                    assertTrue(result.getOutput().contains("roleLayers=mainBase,mainAmd"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }

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

NO CONTENT: file was removed

common/src/main/java/org/implab/gradle/common/sources/VariantAttributes.java removed 0 -71

	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