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

             package org.implab.gradle.common.sources;
             import java.util.Collection;
             import java.util.Collections;
             import java.util.LinkedHashMap;
             import java.util.Optional;
             import javax.inject.Inject;
             import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.model.ObjectFactory;
-            import org.gradle.api.provider.Provider;
-            import org.gradle.api.provider.ProviderFactory;
-            import org.gradle.api.attributes.Attribute;
             import groovy.lang.Closure;
             public abstract class BuildVariant implements Named {
                 private final String name;
                 private final ObjectFactory objects;
                 private boolean finalized;
-                /**
-                 * Variant aggregate parts.
-                 */
-                private final VariantAttributes attributes;
                 private final LinkedHashMap<String, BuildRole> roles = new LinkedHashMap<>();
-                private final LinkedHashMap<String, BuildArtifactSlot> artifactSlots = new LinkedHashMap<>();
                 @Inject
-                public BuildVariant(String name, ObjectFactory objects, ProviderFactory providers) {
+                public BuildVariant(String name, ObjectFactory objects) {
                     this.name = name;
                     this.objects = objects;
-                    attributes = new VariantAttributes(providers);
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
-                /**
-                 * Generic variant attributes interpreted by adapters.
-                 */
-                public VariantAttributes getAttributes() {
-                    return attributes;
-                public void attributes(Action<? super AttributesSpec> action) {
-                    ensureMutable("configure attributes");
-                    action.execute(new AttributesSpec(attributes));
-                public void attributes(Closure<?> configure) {
-                    attributes(Closures.action(configure));
-                public <T> void attribute(Attribute<T> key, T value) {
-                    ensureMutable("set attributes");
-                    attributes.attribute(key, value);
-                public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
-                    ensureMutable("set attributes");
-                    attributes.attributeProvider(key, value);
                 public Collection<BuildRole> getRoles() {
                     return Collections.unmodifiableCollection(roles.values());
                 }
                 public void roles(Action<? super RolesSpec> action) {
                     ensureMutable("configure roles");
                     action.execute(new RolesSpec());
                 }
                 public void roles(Closure<?> configure) {
                     roles(Closures.action(configure));
                 }
                 public BuildRole role(String name, Action<? super BuildRole> configure) {
                     ensureMutable("configure roles");
                     var role = roles.computeIfAbsent(name, this::newRole);
                     configure.execute(role);
                     return role;
                 }
                 public BuildRole role(String name, Closure<?> configure) {
                     return role(name, Closures.action(configure));
                 }
                 public BuildRole role(String name) {
                     return role(name, r -> {
                     });
                 }
                 public Optional<BuildRole> findRole(String name) {
                     return Optional.ofNullable(roles.get(name));
                 }
                 public BuildRole requireRole(String name) {
                     return findRole(name)
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant '" + this.name + "' doesn't define role '" + name + "'"));
                 }
-                public Collection<BuildArtifactSlot> getArtifactSlots() {
-                    return Collections.unmodifiableCollection(artifactSlots.values());
-                public void artifactSlots(Action<? super ArtifactSlotsSpec> action) {
-                    ensureMutable("configure artifact slots");
-                    action.execute(new ArtifactSlotsSpec());
-                public void artifactSlots(Closure<?> configure) {
-                    artifactSlots(Closures.action(configure));
-                public BuildArtifactSlot artifactSlot(String name) {
-                    return artifactSlot(name, it -> {
-                    });
-                public BuildArtifactSlot artifactSlot(String name, Action<? super BuildArtifactSlot> configure) {
-                    ensureMutable("configure artifact slots");
-                    var slot = artifactSlots.computeIfAbsent(name, this::newArtifactSlot);
-                    configure.execute(slot);
-                    return slot;
-                public BuildArtifactSlot artifactSlot(String name, Closure<?> configure) {
-                    return artifactSlot(name, Closures.action(configure));
-                public Optional<BuildArtifactSlot> findArtifactSlot(String name) {
-                    return Optional.ofNullable(artifactSlots.get(name));
-                public BuildArtifactSlot requireArtifactSlot(String name) {
-                    return findArtifactSlot(name)
-                            .orElseThrow(() -> new InvalidUserDataException(
-                                    "Variant '" + this.name + "' doesn't define artifact slot '" + name + "'"));
                 void finalizeModel() {
                     if (finalized)
                         return;
                     for (var role : roles.values())
                         role.finalizeModel();
-                    attributes.finalizeModel();
                     finalized = true;
                 }
                 private BuildRole newRole(String roleName) {
                     return objects.newInstance(BuildRole.class, roleName);
                 }
-                private BuildArtifactSlot newArtifactSlot(String slotName) {
-                    return objects.newInstance(BuildArtifactSlot.class, slotName);
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("Variant '" + name + "' is finalized and cannot " + operation);
                 }
                 public final class RolesSpec {
                     public BuildRole role(String name, Action<? super BuildRole> configure) {
                         return BuildVariant.this.role(name, configure);
                     }
                     public BuildRole role(String name, Closure<?> configure) {
                         return BuildVariant.this.role(name, configure);
                     }
                     public BuildRole role(String name) {
                         return BuildVariant.this.role(name);
                     }
                     public Collection<BuildRole> getAll() {
                         return BuildVariant.this.getRoles();
                     }
                     public Optional<BuildRole> find(String name) {
                         return BuildVariant.this.findRole(name);
                     }
                     public BuildRole require(String name) {
                         return BuildVariant.this.requireRole(name);
                     }
                 }
-                public final class ArtifactSlotsSpec {
-                    public BuildArtifactSlot artifactSlot(String name, Action<? super BuildArtifactSlot> configure) {
-                        return BuildVariant.this.artifactSlot(name, configure);
-                    public BuildArtifactSlot artifactSlot(String name, Closure<?> configure) {
-                        return BuildVariant.this.artifactSlot(name, configure);
-                    public BuildArtifactSlot artifactSlot(String name) {
-                        return BuildVariant.this.artifactSlot(name);
-                    public Collection<BuildArtifactSlot> getAll() {
-                        return BuildVariant.this.getArtifactSlots();
-                    public Optional<BuildArtifactSlot> find(String name) {
-                        return BuildVariant.this.findArtifactSlot(name);
-                    public BuildArtifactSlot require(String name) {
-                        return BuildVariant.this.requireArtifactSlot(name);
-                public static final class AttributesSpec {
-                    private final VariantAttributes attributes;
-                    AttributesSpec(VariantAttributes attributes) {
-                        this.attributes = attributes;
-                    public <T> void attribute(Attribute<T> key, T value) {
-                        attributes.attribute(key, value);
-                    public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
-                        attributes.attributeProvider(key, value);
-                    public void string(String name, String value) {
-                        attribute(Attribute.of(name, String.class), value);
-                    public void string(String name, Provider<? extends String> value) {
-                        attributeProvider(Attribute.of(name, String.class), value);
-                    public void bool(String name, boolean value) {
-                        attribute(Attribute.of(name, Boolean.class), value);
-                    public void bool(String name, Provider<? extends Boolean> value) {
-                        attributeProvider(Attribute.of(name, Boolean.class), value);
-                    public void integer(String name, int value) {
-                        attribute(Attribute.of(name, Integer.class), value);
-                    public void integer(String name, Provider<? extends Integer> value) {
-                        attributeProvider(Attribute.of(name, Integer.class), value);
-                    public VariantAttributes asAttributes() {
-                        return attributes;
             }

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

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.Collection;
             import java.util.Collections;
             import java.util.LinkedHashMap;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Map;
             import java.util.Optional;
             import javax.inject.Inject;
             import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.model.ObjectFactory;
             import groovy.lang.Closure;
             public abstract class BuildVariantsExtension {
                 private final NamedDomainObjectContainer<BuildLayer> layers;
                 private final NamedDomainObjectContainer<BuildVariant> variants;
                 private final List<Action<? super BuildVariantsExtension>> finalizedActions = new ArrayList<>();
                 private boolean finalized;
                 @Inject
                 public BuildVariantsExtension(ObjectFactory objects) {
                     layers = objects.domainObjectContainer(BuildLayer.class);
                     variants = objects.domainObjectContainer(BuildVariant.class);
                     layers.all(layer -> {
                         if (finalized)
                             throw new InvalidUserDataException(
                                     "Variants model is finalized and cannot add layer '" + layer.getName() + "'");
                     });
                     variants.all(variant -> {
                         if (finalized)
                             throw new InvalidUserDataException(
                                     "Variants model is finalized and cannot add variant '" + variant.getName() + "'");
                     });
                 }
                 public NamedDomainObjectContainer<BuildLayer> getLayers() {
                     return layers;
                 }
                 public NamedDomainObjectContainer<BuildVariant> getVariants() {
                     return variants;
                 }
                 public void layers(Action<? super NamedDomainObjectContainer<BuildLayer>> action) {
                     ensureMutable("configure layers");
                     action.execute(layers);
                 }
                 public void layers(Closure<?> configure) {
                     layers(Closures.action(configure));
                 }
                 public void variants(Action<? super NamedDomainObjectContainer<BuildVariant>> action) {
                     ensureMutable("configure variants");
                     action.execute(variants);
                 }
                 public void variants(Closure<?> configure) {
                     variants(Closures.action(configure));
                 }
                 public BuildLayer layer(String name, Action<? super BuildLayer> configure) {
                     ensureMutable("configure layers");
                     var layer = layers.maybeCreate(name);
                     configure.execute(layer);
                     return layer;
                 }
                 public BuildLayer layer(String name, Closure<?> configure) {
                     return layer(name, Closures.action(configure));
                 }
                 public BuildLayer layer(String name) {
                     return layer(name, it -> {
                     });
                 }
                 public BuildVariant variant(String name, Action<? super BuildVariant> configure) {
                     ensureMutable("configure variants");
                     var variant = variants.maybeCreate(name);
                     configure.execute(variant);
                     return variant;
                 }
                 public BuildVariant variant(String name, Closure<?> configure) {
                     return variant(name, Closures.action(configure));
                 }
                 public BuildVariant variant(String name) {
                     return variant(name, it -> {
                     });
                 }
                 public void all(Action<? super BuildVariant> action) {
                     variants.all(action);
                 }
                 public void all(Closure<?> configure) {
                     all(Closures.action(configure));
                 }
                 public Collection<BuildVariant> getAll() {
                     var all = new ArrayList<BuildVariant>();
                     variants.forEach(all::add);
                     return Collections.unmodifiableList(all);
                 }
                 public Optional<BuildVariant> find(String name) {
                     return Optional.ofNullable(variants.findByName(name));
                 }
                 public BuildVariant require(String name) {
                     return find(name)
                             .orElseThrow(() -> new InvalidUserDataException("Variant '" + name + "' isn't defined"));
                 }
                 public void whenFinalized(Action<? super BuildVariantsExtension> action) {
                     if (finalized) {
                         action.execute(this);
                         return;
                     }
                     finalizedActions.add(action);
                 }
                 public void whenFinalized(Closure<?> configure) {
                     whenFinalized(Closures.action(configure));
                 }
                 public boolean isFinalized() {
                     return finalized;
                 }
                 public void finalizeModel() {
                     if (finalized)
                         return;
                     validate();
                     for (var variant : variants)
                         variant.finalizeModel();
                     finalized = true;
                     var actions = new ArrayList<>(finalizedActions);
                     finalizedActions.clear();
                     for (var action : actions)
                         action.execute(this);
                 }
                 public void validate() {
                     var errors = new ArrayList<String>();
                     var layersByName = new LinkedHashMap<String, BuildLayer>();
                     for (var layer : layers) {
                         var layerName = normalize(layer.getName());
                         if (layerName == null) {
                             errors.add("Layer name must not be blank");
                             continue;
                         }
                         var previous = layersByName.putIfAbsent(layerName, layer);
                         if (previous != null) {
                             errors.add("Layer '" + layerName + "' is declared more than once");
                         }
                     }
                     for (var variant : variants)
                         validateVariant(variant, layersByName, errors);
                     if (!errors.isEmpty()) {
                         var message = new StringBuilder("Invalid variants model:");
                         for (var error : errors)
                             message.append("\n - ").append(error);
                         throw new InvalidUserDataException(message.toString());
                     }
                 }
                 private static void validateVariant(BuildVariant variant, Map<String, BuildLayer> layersByName, List<String> errors) {
                     var variantName = normalize(variant.getName());
                     if (variantName == null) {
                         errors.add("Variant name must not be blank");
                         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());
                         if (roleName == null) {
                             errors.add("Variant '" + variant.getName() + "' contains blank role name");
                             continue;
                         }
                         if (!roleNames.add(roleName)) {
                             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,
                         List<String> errors) {
                     for (var role : variant.getRoles()) {
                         var seenLayers = new LinkedHashSet<String>();
                         for (var layerName : role.getLayers().getOrElse(List.of())) {
                             var normalizedLayerName = normalize(layerName);
                             if (normalizedLayerName == null) {
                                 errors.add("Variant '" + variant.getName() + "', role '" + role.getName() + "' contains blank layer name");
                                 continue;
                             }
                             var layer = layersByName.get(normalizedLayerName);
                             if (layer == null) {
                                 errors.add("Variant '" + variant.getName() + "' references unknown layer '" + normalizedLayerName + "'");
                                 continue;
                             }
                             if (!seenLayers.add(normalizedLayerName)) {
                                 errors.add("Variant '" + variant.getName() + "', role '" + role.getName()
                                         + "' contains duplicated layer reference '" + normalizedLayerName + "'");
                             }
                         }
                     }
                 }
                 private static String normalize(String value) {
                     if (value == null)
                         return null;
                     var trimmed = value.trim();
                     return trimmed.isEmpty() ? null : trimmed;
                 }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("Variants model is finalized and cannot " + operation);
                 }
             }

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

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.regex.Matcher;
             import java.util.regex.Pattern;
             import java.util.stream.Stream;
             import javax.inject.Inject;
             import org.implab.gradle.common.core.lang.Closures;
             import org.implab.gradle.common.core.lang.Strings;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.eclipse.jdt.annotation.Nullable;
             import org.gradle.api.Action;
             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;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             import static org.implab.gradle.common.core.lang.Strings.sanitizeName;
             /**
              * Adapter extension that registers source sets for variant/layer pairs.
              */
             @NonNullByDefault
             public abstract class VariantSourcesExtension {
                 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 final List<SourceSetRegistration> registeredContexts = new ArrayList<>();
                 private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();
                 private final LinkedHashMap<String, NamedDomainObjectProvider<GenericSourceSet>> sourceSetsByName = new LinkedHashMap<>();
                 private final LinkedHashMap<String, String> sourceSetLayersByName = new LinkedHashMap<>();
                 private boolean sourceSetsRegistered;
                 @Inject
-                public VariantSourcesExtension(ObjectFactory objects) {
+                public VariantSourcesExtension(ObjectFactory objects, ProjectLayout layout) {
+                    this.layout = layout;
                     bindings = objects.domainObjectContainer(BuildLayerBinding.class);
                 }
                 public NamedDomainObjectContainer<BuildLayerBinding> getBindings() {
                     return bindings;
                 }
                 public void bindings(Action<? super NamedDomainObjectContainer<BuildLayerBinding>> action) {
                     action.execute(bindings);
                 }
                 public void bindings(
                         @DelegatesTo(value = NamedDomainObjectContainer.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     bindings(Closures.action(action));
                 }
                 public BuildLayerBinding bind(String layer) {
                     return bindings.maybeCreate(normalize(layer, "Layer name must not be null or blank"));
                 }
                 /**
                  * Configures per-layer binding.
                  */
                 public BuildLayerBinding bind(String layer, Action<? super BuildLayerBinding> configure) {
                     var binding = bind(layer);
                     configure.execute(binding);
                     return binding;
                 }
                 public BuildLayerBinding bind(String layer,
                         @DelegatesTo(value = BuildLayerBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return bind(layer, Closures.action(configure));
                 }
                 /**
                  * Global callback fired for each registered source set.
                  * Already emitted registrations are delivered immediately (replay).
                  * For simple callbacks you can use delegate-only style
                  * (for example {@code whenRegistered { sourceSetName() }}).
                  * For nested closures prefer explicit parameter
                  * ({@code whenRegistered { ctx -> ... }}).
                  */
                 public void whenRegistered(Action<? super SourceSetRegistration> action) {
                     registeredActions.add(action);
                     for (var context : registeredContexts)
                         action.execute(context);
                 }
                 public void whenRegistered(
                         @DelegatesTo(value = SourceSetRegistration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenRegistered(Closures.action(action));
                 }
                 /**
                  * Global callback fired for every resolved variant/role/layer usage.
                  * Already emitted usage bindings are delivered immediately (replay).
                  * For simple callbacks you can use delegate-only style
                  * (for example {@code whenBound { variantName() }}).
                  * For nested closures prefer explicit parameter
                  * ({@code whenBound { ctx -> ... }}).
                  */
                 public void whenBound(Action<? super SourceSetUsageBinding> action) {
                     boundActions.add(action);
                     for (var context : boundContexts)
                         action.execute(context);
                 }
                 public void whenBound(
                         @DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenBound(Closures.action(action));
                 }
                 public void whenBound(String variantName, Action<? super SourceSetUsageBinding> action) {
                     var normalizedVariantName = normalize(variantName, "variantName must not be null or blank");
                     whenBound(filterByVariant(normalizedVariantName, action));
                 }
                 public void whenBound(String variantName,
                         @DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenBound(variantName, Closures.action(action));
                 }
                 void registerSourceSets(BuildVariantsExtension variants, NamedDomainObjectContainer<GenericSourceSet> sources) {
                     if (sourceSetsRegistered) {
                         throw new InvalidUserDataException("variantSources source sets are already registered");
                     }
                     validateBindings(variants);
                     var usages = layerUsages(variants).toList();
                     var registeredBefore = registeredContexts.size();
                     var boundBefore = boundContexts.size();
                     logger.debug(
                             "Starting variant source-set registration (variants={}, layers={}, bindings={}, usages={})",
                             variants.getVariants().size(),
                             variants.getLayers().size(),
                             bindings.size(),
                             usages.size());
                     usages.forEach(usage -> registerLayerUsage(usage, sources));
                     logger.debug(
                             "Completed variant source-set registration (newSourceSets={}, newBounds={}, totalSourceSets={})",
                             registeredContexts.size() - registeredBefore,
                             boundContexts.size() - boundBefore,
                             sourceSetsByName.size());
                     sourceSetsRegistered = true;
                 }
                 private Stream<LayerUsage> layerUsages(BuildVariantsExtension variants) {
                     return variants.getVariants().stream()
                             .flatMap(variant -> variant.getRoles().stream()
                                     .flatMap(role -> role.getLayers().getOrElse(List.of()).stream()
                                             .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) {
                     var resolvedBinding = bind(usage.layerName());
                     var sourceSetNamePattern = resolvedBinding.getSourceSetNamePattern();
                     sourceSetNamePattern.finalizeValueOnRead();
                     var sourceSetName = sourceSetName(usage, sourceSetNamePattern.get());
                     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(),
                             usage.roleName(),
                             usage.layerName(),
                             sourceSetName,
                             sourceSet);
                     if (isNewSourceSet) {
                         var registration = new SourceSetRegistration(
                                 usage.layerName(),
                                 sourceSetName,
                                 sourceSet);
                         resolvedBinding.notifyRegistered(registration);
                         notifyRegistered(registration);
                     }
                     resolvedBinding.notifyBound(binding);
                     notifyBound(binding);
                 }
                 private void notifyRegistered(SourceSetRegistration registration) {
                     registeredContexts.add(registration);
                     for (var action : registeredActions)
                         action.execute(registration);
                 }
                 private void notifyBound(SourceSetUsageBinding binding) {
                     boundContexts.add(binding);
                     for (var action : boundActions)
                         action.execute(binding);
                 }
                 private static Action<? super SourceSetUsageBinding> filterByVariant(String variantName,
                         Action<? super SourceSetUsageBinding> action) {
                     return binding -> {
                         if (variantName.equals(binding.variantName()))
                             action.execute(binding);
                     };
                 }
                 private void ensureSourceSetNameBoundToSingleLayer(String sourceSetName, String layerName) {
                     var existingLayer = sourceSetLayersByName.putIfAbsent(sourceSetName, layerName);
                     if (existingLayer != null && !existingLayer.equals(layerName)) {
                         throw new InvalidUserDataException("Source set '" + sourceSetName + "' is resolved from multiple layers: '"
                                 + existingLayer + "' and '" + layerName + "'");
                     }
                 }
                 private void validateBindings(BuildVariantsExtension variants) {
                     var knownLayerNames = new java.util.LinkedHashSet<String>();
                     for (var layer : variants.getLayers())
                         knownLayerNames.add(layer.getName());
                     var errors = new ArrayList<String>();
                     for (var binding : bindings) {
                         if (!knownLayerNames.contains(binding.getName())) {
                             errors.add("Layer binding '" + binding.getName() + "' references unknown layer");
                         }
                     }
                     if (!errors.isEmpty()) {
                         var message = new StringBuilder("Invalid variantSources model:");
                         for (var error : errors)
                             message.append("\n - ").append(error);
                         throw new InvalidUserDataException(message.toString());
                     }
                 }
                 private static String sourceSetName(LayerUsage usage, String pattern) {
                     var normalizedPattern = normalize(pattern, "sourceSetNamePattern must not be null or blank");
                     var resolved = resolveSourceSetNamePattern(normalizedPattern, usage);
                     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;
                 }
                 private static String resolveSourceSetNamePattern(String pattern, LayerUsage usage) {
                     var matcher = SOURCE_SET_NAME_TOKEN.matcher(pattern);
                     var output = new StringBuffer();
                     while (matcher.find()) {
                         var token = matcher.group(1);
                         matcher.appendReplacement(output, Matcher.quoteReplacement(tokenValue(token, usage)));
                     }
                     matcher.appendTail(output);
                     return output.toString();
                 }
                 private static String tokenValue(String token, LayerUsage usage) {
                     return switch (token) {
                         case "variant" -> sanitizeName(usage.variantName());
                         case "variantCap" -> Strings.capitalize(sanitizeName(usage.variantName()));
                         case "role" -> sanitizeName(usage.roleName());
                         case "roleCap" -> Strings.capitalize(sanitizeName(usage.roleName()));
                         case "layer" -> sanitizeName(usage.layerName());
                         case "layerCap" -> Strings.capitalize(sanitizeName(usage.layerName()));
                         default -> throw new InvalidUserDataException(
                                 "sourceSetNamePattern contains unsupported token '{" + token + "}'");
                     };
                 }
                 private static String normalize(@Nullable String value, String errorMessage) {
                     if (value == null)
                         throw new InvalidUserDataException(errorMessage);
                     var trimmed = value.trim();
                     if (trimmed.isEmpty())
                         throw new InvalidUserDataException(errorMessage);
                     return trimmed;
                 }
                 private record LayerUsage(String variantName, String roleName, String layerName) {
                 }
             }

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>
              * <li>{@code whenXxx(...)}: register callback (supports replay where documented);</li>
              * <li>{@code configureXxx(...)}: configure model elements;</li>
              * <li>{@code notifyXxx(...)}: internal event dispatch helpers (not part of public DSL).</li>
              * </ul>
              *
              * <p>Closure-based callbacks use delegate-first resolution via
              * {@code @DelegatesTo}. Delegate-only style is suitable for simple callbacks.
              * For nested closures prefer explicit callback parameters ({@code ctx -> ...}).
              */
             package org.implab.gradle.common.sources;

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

             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 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 VariantsPluginFunctionalTest {
                 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-fixture'\n";
                 @TempDir
                 Path testProjectDir;
                 @Test
                 void configuresVariantModelWithDsl() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('mainBase') {
                             }
                             layer('mainAmd') {
                             }
                             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);
                 }
                 @Test
                 void failsOnUnknownLayerReference() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('mainBase') {
                             }
                             variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'missingLayer')
                                 }
                             }
                         }
                         """, "references unknown layer 'missingLayer'");
                 }
                 @Test
                 void allowsUsingLayerFromDifferentVariantRole() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('mainBase')
                             variant('browser') {
                                 role('test') {
                                     layers('mainBase')
                                 }
                             }
                         }
                         """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("BUILD SUCCESSFUL"));
                 }
                 @Test
                 void failsOnDuplicatedLayerReferenceInRole() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') {
                                     layers('a', 'a')
                                 }
                             }
                         }
                         """, "contains duplicated layer reference 'a'");
                 }
                 @Test
                 void failsOnLateLayerMutationAfterFinalize() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') { layers('a') }
                             }
                         }
                         afterEvaluate {
                             variants.layer('late')
                         }
                         """, "Variants model is finalized and cannot configure layers");
                 }
                 @Test
                 void failsOnLateVariantMutationAfterFinalize() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') { layers('a') }
                             }
                         }
                         afterEvaluate {
                             variants.require('browser').role('late') { layers('a') }
                         }
                         """, "Variant 'browser' is finalized and cannot configure roles");
                 }
                 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(BuildVariant.class
                                 .getProtectionDomain()
                                 .getCodeSource()
                                 .getLocation()
                                 .toURI());
                         var markerResource = VariantsPlugin.class.getClassLoader()
                                 .getResource("META-INF/gradle-plugins/org.implab.gradle-variants.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/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