implab/gradle-common Commit - r51:9db7822cd26c

Rework variant artifacts materialization model...

cin -

r51:9db7822cd26c default

parent child

Context file:

r51:9db7822cd26c

Expand all files

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyHandler.java created 644 +218 0

@@ -0,0 +1,218
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import java.util.HashMap;
	4	import java.util.HashSet;
	5	import java.util.Map;
	6	import java.util.Set;
	7
	8	import org.eclipse.jdt.annotation.NonNullByDefault;
	9	import org.gradle.api.Action;
	10	import org.gradle.api.file.ConfigurableFileCollection;
	11	import org.gradle.api.file.Directory;
	12	import org.gradle.api.file.DirectoryProperty;
	13	import org.gradle.api.file.FileCollection;
	14	import org.gradle.api.model.ObjectFactory;
	15	import org.gradle.api.provider.Provider;
	16	import org.gradle.api.tasks.Sync;
	17	import org.gradle.api.tasks.TaskContainer;
	18	import org.gradle.language.base.plugins.LifecycleBasePlugin;
	19	import org.implab.gradle.common.core.lang.FilePaths;
	20	import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
	21	import org.implab.gradle.variants.artifacts.ArtifactSlot;
	22	import org.implab.gradle.variants.sources.CompileUnit;
	23	import org.implab.gradle.variants.sources.CompileUnitsView;
	24	import org.implab.gradle.variants.sources.RoleProjectionsView;
	25	import org.implab.gradle.variants.sources.SourceSetMaterializer;
	26
	27	/**
	28	* Адаптер между фрагментами артефактов, представленными в виде
	29	* {@link SlotContribution},
	30	* и ArtifactAssemblyRegistry, который оперирует уже собранными
	31	* {@link ArtifactAssembly}.
	32	*
	33	* Данный класс отвечает за сборку отдельных фрагментов артефактов в единый
	34	* каталог, который затем регистрируется в ArtifactAssemblyRegistry в виде
	35	* {@link ArtifactAssembly}. Сборка конечного артефакта происходит при помощи
	36	* задачи, которая копирует все входные файлы в выходной каталог. Задача
	37	* создается для каждого {@link ArtifactSlot} и использует
	38	* {@link SlotAssembly#inputs()} как источник входных данных.
	39	*
	40	* Для сборки используется паттерн Visitor: каждый фрагмент артефакта
	41	* представлен в виде реализации интерфейса {@link SlotContribution}, который
	42	* имеет метод accept, принимающий Visitor.
	43	* Visitor реализован во внутреннем классе {@link ContributionVisitor}, который
	44	* знает, как обрабатывать каждый тип фрагмента и добавлять его в сборку.
	45	* Для каждого {@link SlotContribution} создается ключ {@link SlotInputKey},
	46	* который используется для дедупликации: если фрагмент с таким же ключом уже
	47	* был добавлен, то он игнорируется.
	48	*/
	49	@NonNullByDefault
	50	public class ArtifactAssemblyHandler {
	51	private final ObjectFactory objects;
	52
	53	private final ArtifactAssemblyRegistry assemblyRegistry;
	54
	55	private final DirectoryProperty assembliesDirectory;
	56
	57	private final TaskContainer tasks;
	58
	59	private final CompileUnitsView compileUnitsView;
	60
	61	private final RoleProjectionsView roleProjectionsView;
	62
	63	private final SourceSetMaterializer sourceSetMaterializer;
	64
	65	private final Map<ArtifactSlot, SlotAssembly> slotInputs = new HashMap<>();
	66
	67	public ArtifactAssemblyHandler(
	68	ObjectFactory objects,
	69	TaskContainer tasks,
	70	ArtifactAssemblyRegistry assemblyRegistry,
	71	CompileUnitsView compileUnitsView,
	72	RoleProjectionsView roleProjectionsView,
	73	SourceSetMaterializer sourceSetMaterializer) {
	74	this.objects = objects;
	75	this.tasks = tasks;
	76	this.assemblyRegistry = assemblyRegistry;
	77	this.compileUnitsView = compileUnitsView;
	78	this.roleProjectionsView = roleProjectionsView;
	79	this.sourceSetMaterializer = sourceSetMaterializer;
	80
	81	assembliesDirectory = objects.directoryProperty();
	82	}
	83
	84	public DirectoryProperty getAssembliesDirectory() {
	85	return assembliesDirectory;
	86	}
	87
	88	public void configureAssembly(ArtifactSlot artifactSlot, Action<? super ArtifactAssemblySpec> action) {
	89	var visitor = contributionVisitor(artifactSlot);
	90	var spec = new DefaultArtifactAssemblySpec(objects, c -> c.accept(visitor));
	91	action.execute(spec);
	92	}
	93
	94	public SlotContributionVisitor contributionVisitor(ArtifactSlot artifactSlot) {
	95	var assembly = slotInputs.computeIfAbsent(artifactSlot, this::createSlotAssembly);
	96	return new ContributionVisitor(artifactSlot, assembly);
	97	}
	98
	99	/**
	100	* Создает сборку для указанного слота артефакта, сборка регистрируется в
	101	* ArtifactAssemblyRegistry, если для слота сборка уже была зарегистрирована
	102	* кем-то еще, то возникает ошибка.
	103	*/
	104	private SlotAssembly createSlotAssembly(ArtifactSlot artifactSlot) {
	105	var assembly = new SlotAssembly();
	106	var fileCollection = assembly.inputs();
	107
	108	var outputDirectory = outputDirectory(artifactSlot);
	109
	110	var task = tasks.register(assembleTaskName(artifactSlot), Sync.class, copy -> {
	111	copy.setGroup(LifecycleBasePlugin.BUILD_GROUP);
	112	copy.into(outputDirectory);
	113	copy.from(fileCollection);
	114	});
	115
	116	assemblyRegistry.register(artifactSlot, task, t -> outputDirectory);
	117
	118	return assembly;
	119	}
	120
	121	private String assembleTaskName(ArtifactSlot artifactSlot) {
	122	var variantName = artifactSlot.variant().getName();
	123	var slotName = artifactSlot.slot().getName();
	124
	125	return "assembleVariantArtifactSlot"
	126	+ "_v" + variantName.length() + "_" + variantName
	127	+ "_s" + slotName.length() + "_" + slotName;
	128	}
	129
	130	private Provider<Directory> outputDirectory(ArtifactSlot artifactSlot) {
	131	return assembliesDirectory.dir(
	132	FilePaths.cat(
	133	artifactSlot.variant().getName(),
	134	artifactSlot.slot().getName()));
	135	}
	136
	137	/**
	138	* Собирает отдельные фрагменты артефактов в единый источник
	139	* {@link ConfigurableFileCollection}.
	140	* Для фрагментов {@link SlotContribution} используется механизм дедупликации:
	141	* для каждого
	142	* водящего фрагмента создается ключ {@link SlotInputKey} и добавляются
	143	* фрагменты только
	144	* с уникальным ключом, повторы игнорируются.
	145	*/
	146	private class ContributionVisitor implements SlotContributionVisitor {
	147	// artifact slot for this assembly
	148	private final ArtifactSlot artifactSlot;
	149
	150	// seen inputs, used for deduplication
	151	private final SlotAssembly assembly;
	152
	153	ContributionVisitor(ArtifactSlot artifactSlot, SlotAssembly assembly) {
	154	this.artifactSlot = artifactSlot;
	155	this.assembly = assembly;
	156	}
	157
	158	@Override
	159	public void visit(DirectContribution contribution) {
	160	contribute(
	161	SlotInputKey.newUniqueKey("Direct input for " + artifactSlot),
	162	contribution.input());
	163	}
	164
	165	@Override
	166	public void visit(VariantOutputsContribution contribution) {
	167	var units = compileUnitsView.getUnitsForVariant(artifactSlot.variant());
	168	contributeCompileUnits(units, contribution.outputs());
	169	}
	170
	171	@Override
	172	public void visit(RoleOutputsContribution contribution) {
	173	var roleProjection = roleProjectionsView.requireProjection(artifactSlot.variant(),
	174	contribution.role());
	175	var units = roleProjectionsView.getUnits(roleProjection);
	176
	177	contributeCompileUnits(units, contribution.outputs());
	178
	179	}
	180
	181	@Override
	182	public void visit(LayerOutputsContribution contribution) {
	183	var unit = compileUnitsView.requireUnit(artifactSlot.variant(), contribution.layer());
	184	contributeCompileUnits(Set.of(unit), contribution.outputs());
	185	}
	186
	187	private void contributeCompileUnits(Set<CompileUnit> units, Set<String> outputs) {
	188	units.stream()
	189	// expand variant compile units, make (compileUnit, outputName) pairs
	190	.flatMap(unit -> outputs.stream()
	191	.map(output -> new CompileUnitOutputKey(unit, output)))
	192	.forEach(key -> contribute(
	193	key,
	194	sourceSetMaterializer.getSourceSet(key.unit())
	195	.map(s -> s.output(key.outputName()))));
	196	}
	197
	198	private void contribute(SlotInputKey key, Object resolvedInput) {
	199	assembly.addSlotInput(key, resolvedInput);
	200	}
	201	}
	202
	203	/** Состояние для отдельного слота */
	204	class SlotAssembly {
	205	private final ConfigurableFileCollection inputs = objects.fileCollection();
	206	private final Set<SlotInputKey> seen = new HashSet<>();
	207
	208	public void addSlotInput(SlotInputKey key, Object input) {
	209	if (!seen.add(key))
	210	return;
	211	inputs.from(input);
	212	}
	213
	214	public FileCollection inputs() {
	215	return inputs;
	216	}
	217	}
	218	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultOutgoingVariantsContext.java created 644 +94 0

@@ -0,0 +1,94
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import java.util.Optional;
	4
	5	import org.gradle.api.Action;
	6	import org.implab.gradle.variants.artifacts.ArtifactAssemblies;
	7	import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
	8	import org.implab.gradle.variants.artifacts.ArtifactSlot;
	9	import org.implab.gradle.variants.artifacts.OutgoingConfigurationSlotSpec;
	10	import org.implab.gradle.variants.artifacts.OutgoingConfigurationSpec;
	11	import org.implab.gradle.variants.artifacts.OutgoingVariant;
	12	import org.implab.gradle.variants.artifacts.OutgoingVariantsContext;
	13	import org.implab.gradle.variants.artifacts.VariantArtifactsSpec;
	14	import org.implab.gradle.variants.core.Variant;
	15
	16	public class DefaultOutgoingVariantsContext implements OutgoingVariantsContext {
	17	private final ArtifactAssemblies assemblies;
	18
	19	private final ArtifactAssemblyHandler assemblyHandler;
	20
	21	private final OutgoingRegistry outgoingVariants;
	22
	23	private final MaterializationPolicyHandler materializationHandler;
	24
	25	public DefaultOutgoingVariantsContext(
	26	ArtifactAssemblies assemblies,
	27	OutgoingRegistry outgoingVariants,
	28	ArtifactAssemblyHandler assemblyHandler,
	29	MaterializationPolicyHandler materializationHandler) {
	30	this.assemblies = assemblies;
	31	this.outgoingVariants = outgoingVariants;
	32	this.assemblyHandler = assemblyHandler;
	33	this.materializationHandler = materializationHandler;
	34	}
	35
	36	@Override
	37	public ArtifactAssemblies getAssemblies() {
	38	return assemblies;
	39	}
	40
	41	@Override
	42	public void configureVariant(Variant variant, Action<? super VariantArtifactsSpec> action) {
	43	var outgoingVariant = outgoingVariants.maybeCreate(variant);
	44	var variantSpec = new VariantSpec(outgoingVariant);
	45	action.execute(variantSpec);
	46	}
	47
	48	@Override
	49	public void configureEach(Action<? super OutgoingVariant> action) {
	50	outgoingVariants.configureEach(action::execute);
	51	}
	52
	53	@Override
	54	public Optional<OutgoingVariant> findOutgoing(Variant variant) {
	55	return outgoingVariants.find(variant);
	56	}
	57
	58	@Override
	59	public void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action) {
	60	materializationHandler.whenVariantMaterialized(action);
	61	}
	62
	63	@Override
	64	public void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action) {
	65	materializationHandler.whenSlotMaterialized(action);
	66	}
	67
	68	class VariantSpec implements VariantArtifactsSpec {
	69
	70	private final OutgoingVariant outgoingVariant;
	71
	72	VariantSpec(OutgoingVariant outgoingVariant) {
	73	this.outgoingVariant = outgoingVariant;
	74	}
	75
	76	@Override
	77	public void slot(String name, Action<? super ArtifactAssemblySpec> action) {
	78	var slot = outgoingVariant.getSlots().maybeCreate(name);
	79	var artifactSlot = new ArtifactSlot(outgoingVariant.getVariant(), slot);
	80	assemblyHandler.configureAssembly(artifactSlot, action);
	81	}
	82
	83	@Override
	84	public void primarySlot(String name, Action<? super ArtifactAssemblySpec> action) {
	85	var slot = outgoingVariant.getSlots().maybeCreate(name);
	86	var artifactSlot = new ArtifactSlot(outgoingVariant.getVariant(), slot);
	87	assemblyHandler.configureAssembly(artifactSlot, action);
	88
	89	outgoingVariant.getPrimarySlot().set(slot);
	90	}
	91
	92	}
	93
	94	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/MaterializationPolicyHandler.java created 644 +118 0

@@ -0,0 +1,118
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import org.eclipse.jdt.annotation.NonNullByDefault;
	4	import org.gradle.api.Action;
	5	import org.gradle.api.artifacts.Configuration;
	6	import org.gradle.api.attributes.AttributeContainer;
	7	import org.implab.gradle.internal.ReplayableQueue;
	8	import org.implab.gradle.variants.artifacts.ArtifactAssemblies;
	9	import org.implab.gradle.variants.artifacts.ArtifactAssembly;
	10	import org.implab.gradle.variants.artifacts.ArtifactSlot;
	11	import org.implab.gradle.variants.artifacts.OutgoingConfigurationSlotSpec;
	12	import org.implab.gradle.variants.artifacts.OutgoingConfigurationSpec;
	13	import org.implab.gradle.variants.artifacts.OutgoingVariant;
	14	import org.implab.gradle.variants.core.Variant;
	15
	16	/**
	17	* Handles outgoing artifact materialization policy.
	18	*
	19	* <p>Materialization is the phase where the plugin interprets variant artifact
	20	* declarations as Gradle outgoing publication state: a consumable configuration,
	21	* its primary artifact set, secondary artifact variants, attributes, and backing
	22	* assembly tasks.
	23	*
	24	* <p>The handler provides extension points for customizing the materialized
	25	* Gradle-facing objects. These hooks intentionally expose Gradle API objects.
	26	* This allows advanced customization, but also means that callers can bypass
	27	* the plugin model. Such customizations are considered caller responsibility.
	28	*
	29	* <p>The internal binding mechanics are not part of the public contract. The
	30	* contract is the materialized outgoing state exposed through the specification
	31	* objects.
	32	*/
	33	@NonNullByDefault
	34	public class MaterializationPolicyHandler implements Action<OutgoingVariant> {
	35
	36	private final ArtifactAssemblies resolver;
	37
	38	private final ReplayableQueue<OutgoingConfigurationSpec> variantMaterialization = new ReplayableQueue<>();
	39	private final ReplayableQueue<OutgoingConfigurationSlotSpec> slotMaterialization = new ReplayableQueue<>();
	40
	41	public MaterializationPolicyHandler(ArtifactAssemblies resolver) {
	42	this.resolver = resolver;
	43	}
	44
	45	@Override
	46	public void execute(OutgoingVariant outgoingVariant) {
	47	var slots = outgoingVariant.getSlots();
	48	var primarySlotProvider = outgoingVariant.getPrimarySlot();
	49	var variant = outgoingVariant.getVariant();
	50
	51	// связываем конфигурацию
	52	outgoingVariant.configureOutgoing(configuration -> {
	53	var primarySlot = primarySlotProvider.get();
	54	var outgoing = configuration.getOutgoing();
	55
	56	variantMaterialized(variant, configuration);
	57
	58	slotMaterialized(new ArtifactSlot(variant, primarySlot), true, outgoing.getAttributes());
	59
	60	outgoing.getVariants().configureEach(variantConfiguration -> {
	61	var slotName = variantConfiguration.getName();
	62	var slot = slots.findByName(slotName);
	63	if (slot != null) {
	64	slotMaterialized(new ArtifactSlot(variant, slot), false, variantConfiguration.getAttributes());
	65	}
	66	});
	67	});
	68	};
	69
	70	public void whenVariantMaterialized(Action<? super OutgoingConfigurationSpec> action) {
	71	variantMaterialization.forEach(action::execute);
	72	}
	73
	74	public void whenSlotMaterialized(Action<? super OutgoingConfigurationSlotSpec> action) {
	75	slotMaterialization.forEach(action::execute);
	76	}
	77
	78	private void variantMaterialized(Variant variant, Configuration configuration) {
	79	variantMaterialization.add(new OutgoingConfigurationSpec() {
	80
	81	@Override
	82	public Variant getVariant() {
	83	return variant;
	84	}
	85
	86	@Override
	87	public Configuration getConfiguration() {
	88	return configuration;
	89	}
	90
	91	});
	92	}
	93
	94	private void slotMaterialized(ArtifactSlot slot, boolean primary, AttributeContainer attributes) {
	95	slotMaterialization.add(new OutgoingConfigurationSlotSpec() {
	96	@Override
	97	public boolean isPrimary() {
	98	return primary;
	99	}
	100
	101	@Override
	102	public ArtifactSlot getArtifactSlot() {
	103	return slot;
	104	}
	105
	106	@Override
	107	public ArtifactAssembly getAssembly() {
	108	return resolver.require(slot);
	109	}
	110
	111	@Override
	112	public void artifactAttributes(Action<? super AttributeContainer> action) {
	113	action.execute(attributes);
	114	}
	115	});
	116	}
	117
	118	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/SingleSlotConvention.java created 644 +33 0

@@ -0,0 +1,33
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.InvalidUserDataException;
	5	import org.gradle.api.provider.ProviderFactory;
	6	import org.implab.gradle.variants.artifacts.OutgoingVariant;
	7
	8	public class SingleSlotConvention implements Action<OutgoingVariant> {
	9
	10	private final ProviderFactory providers;
	11
	12	public SingleSlotConvention(ProviderFactory providers) {
	13	this.providers = providers;
	14	}
	15
	16	@Override
	17	public void execute(OutgoingVariant outgoingVariant) {
	18	var slots = outgoingVariant.getSlots();
	19
	20	outgoingVariant.getPrimarySlot().convention(
	21	// если есть ровно один слот, то он считается primary
	22	providers.provider(() -> {
	23	if (slots.size() == 0)
	24	throw new InvalidUserDataException("No slots declared for " + outgoingVariant.getVariant());
	25	if (slots.size() > 1)
	26	throw new InvalidUserDataException("Multiple slots declared for " + outgoingVariant.getVariant() +
	27	", please specify primary slot explicitly");
	28
	29	return slots.stream().findAny().get();
	30	}));
	31	}
	32
	33	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/package-info.java created 644 +9 0

@@ -0,0 +1,9
	1	/**
	2	* Internal implementation of the variant artifacts plugin.
	3	*
	4	* <p>Types in this package are not part of the public API. They may change,
	5	* move, or be removed without compatibility guarantees. Build logic should use
	6	* the public contracts from {@link org.implab.gradle.variants.artifacts}
	7	* instead.
	8	*/
	9	package org.implab.gradle.variants.artifacts.internal;

AGENTS.md +2 0

             # AGENTS.md
             ## Проектные договоренности
+            - для управления исходным кодом используется Mercurial
             ### Публичное API библиотек
             - Предпочтителен `non-null` подход.
             - Там, где значение живет в Gradle Provider API, возвращается `Provider<T>` (не `null`).
             - Там, где lookup синхронный, возвращается `Optional<T>` (не `null`).
             - `find*` рассматривается как синоним legacy `get*` (поиск без `fail-fast`).
             - `require*` это `find*` + `fail-fast` с понятной ошибкой в месте вызова.
             - Для нового API предпочтительны формы `find/require`; новые `get*` по возможности не добавлять.
             - Интерфейсы и классы, описывающие модели DSL должны иметь суффикс `Spec` у моделей описывающих уровень сервисов и состояние сценария сборки такого суффикса не должно быть.
             - Модель расширения на уровне проекта должна иметь суффикс `Extension`.
             ### Документация
             - документирование кода должно быть на английском языке
             - к публичному API
               - описание должно отражать назначение, где используется и какое влияние оказывает на остальные части программы
               - давать небольшое описание концепции, а также краткие примеры
             - к приватному API достаточно давать краткую справку о назначении и использовании
             - реализацию алгоритмов в коде сопровождать комментариями с пояснениями, тривиальные операции пояснять не требуется.
             - документация должна формироваться согласно требованиям по форматированию типа javadoc, jsdoc и т.п., в зависимости от используемых в проекте языках и инструментах.
             ## Identity-first modeling
             Prefer an **identity-first** split between:
             - **identity objects** used for discovery and selection
             - **stateful/materialized objects** obtained through separate API calls
             ### Rules
             - Objects intended for replayable observation (`all(...)`, similar collection APIs) should be **identity objects**.
             - Identity objects must be:
               - cheap to create
               - effectively immutable
               - limited to identity and cheap selection metadata
             - Heavy, computed, provider-based, or runtime-bound state must be resolved separately.
             - Aggregate content should be accessed through dedicated lookup/materialization APIs.
             - Eager observation of identity is acceptable.
             - Eager observation of computed state is not.
             ### Do not
             - Do not store heavy computed state inside identity objects.
             - Do not store runtime references to foreign domains inside identity objects.
             - Do not use custom events when replayable identity registries plus on-demand lookup are sufficient.
             ### Rule of thumb
             **Identity objects contain selection metadata.
             Aggregate content is obtained separately, on demand.**

common/src/main/java/org/implab/gradle/common/core/lang/Strings.java 0 -2

             package org.implab.gradle.common.core.lang;
-            import java.util.function.Consumer;
-            import java.util.function.Function;
             import java.util.regex.Pattern;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.provider.Provider;
             @NonNullByDefault
             public class Strings {
                 private static final boolean[] ALLOWED_FILE_NAME_CHAR = new boolean[128];
                 private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();
                 private static final Pattern firstLetter = Pattern.compile("^\\w");
                 private static final Pattern INVALID_NAME_CHAR = Pattern.compile("[^A-Za-z0-9_.-]");
                 static {
                     for (char c = '0'; c <= '9'; c++)
                         ALLOWED_FILE_NAME_CHAR[c] = true;
                     for (char c = 'A'; c <= 'Z'; c++)
                         ALLOWED_FILE_NAME_CHAR[c] = true;
                     for (char c = 'a'; c <= 'z'; c++)
                         ALLOWED_FILE_NAME_CHAR[c] = true;
                     ALLOWED_FILE_NAME_CHAR['.'] = true;
                     ALLOWED_FILE_NAME_CHAR['_'] = true;
                     ALLOWED_FILE_NAME_CHAR['-'] = true;
                 }
                 public static String capitalize(String string) {
                     return string == null ? null
                             : string.length() == 0 ? string
                                     : firstLetter.matcher(string).replaceFirst(m -> m.group().toUpperCase());
                 }
                 public static String toCamelCase(String name) {
                     if (name == null || name.isEmpty())
                         return name;
                     StringBuilder out = new StringBuilder(name.length());
                     boolean up = false;
                     boolean first = true;
                     for (int i = 0; i < name.length(); i++) {
                         char c = name.charAt(i);
                         switch (c) {
                             case '-', '_', ' ', '.' -> up = true;
                             default -> {
                                 out.append(
                                         first ? Character.toLowerCase(c)
                                                 : up ? Character.toUpperCase(c): c);
                                 up = false;
                                 first = false;
                             }
                         }
                     }
                     return out.toString();
                 }
                 public static void argumentNotNullOrEmpty(String value, String argumentName) {
                     if (value == null || value.length() == 0)
                         throw new IllegalArgumentException(String.format("Argument %s can't be null or empty", argumentName));
                 }
                 public static void argumentNotNullOrBlank(String value, String argumentName) {
                     if (value == null || value.trim().length() == 0)
                         throw new IllegalArgumentException(String.format("Argument %s can't be null or blank", argumentName));
                 }
                 public static String requireNonBlank(String value) {
                     argumentNotNullOrBlank(value, "value");
                     return value;
                 }
                 public static String requireNonEmpty(String value) {
                     argumentNotNullOrEmpty(value, "value");
                     return value;
                 }
                 public static String sanitizeName(String value) {
                     return INVALID_NAME_CHAR.matcher(value).replaceAll("_");
                 }
                 public static String sanitizeFileName(String value) {
                     int length = value.length();
                     for (int i = 0; i < length; i++) {
                         char c = value.charAt(i);
                         if (c >= ALLOWED_FILE_NAME_CHAR.length || !ALLOWED_FILE_NAME_CHAR[c])
                             return sanitizeFileName(value, i);
                     }
                     return value;
                 }
                 public static String asString(Object value) {
                     if (value == null)
                         return null;
                     if (value instanceof Provider<?> provider)
                         return asString(provider.get());
                     else
                         return value.toString();
                 }
                 private static String sanitizeFileName(String value, int invalidIndex) {
                     int length = value.length();
                     StringBuilder out = new StringBuilder(length + 16);
                     out.append(value, 0, invalidIndex);
                     for (int i = invalidIndex; i < length; i++) {
                         char c = value.charAt(i);
                         if (c < ALLOWED_FILE_NAME_CHAR.length && ALLOWED_FILE_NAME_CHAR[c]) {
                             out.append(c);
                         } else if (Character.isHighSurrogate(c) && i + 1 < length && Character.isLowSurrogate(value.charAt(i + 1))) {
                             appendUrlEncodedUtf8(out, Character.toCodePoint(c, value.charAt(++i)));
                         } else if (Character.isSurrogate(c)) {
                             appendUrlEncodedUtf8(out, 0xFFFD);
                         } else {
                             appendUrlEncodedUtf8(out, c);
                         }
                     }
                     return out.toString();
                 }
                 private static void appendUrlEncodedUtf8(StringBuilder out, int codePoint) {
                     if (codePoint <= 0x7F) {
                         appendUrlEncodedByte(out, codePoint);
                     } else if (codePoint <= 0x7FF) {
                         appendUrlEncodedByte(out, 0xC0 | (codePoint >>> 6));
                         appendUrlEncodedByte(out, 0x80 | (codePoint & 0x3F));
                     } else if (codePoint <= 0xFFFF) {
                         appendUrlEncodedByte(out, 0xE0 | (codePoint >>> 12));
                         appendUrlEncodedByte(out, 0x80 | ((codePoint >>> 6) & 0x3F));
                         appendUrlEncodedByte(out, 0x80 | (codePoint & 0x3F));
                     } else {
                         appendUrlEncodedByte(out, 0xF0 | (codePoint >>> 18));
                         appendUrlEncodedByte(out, 0x80 | ((codePoint >>> 12) & 0x3F));
                         appendUrlEncodedByte(out, 0x80 | ((codePoint >>> 6) & 0x3F));
                         appendUrlEncodedByte(out, 0x80 | (codePoint & 0x3F));
                     }
                 }
                 private static void appendUrlEncodedByte(StringBuilder out, int value) {
                     out.append('%');
                     out.append(HEX_DIGITS[(value >>> 4) & 0x0F]);
                     out.append(HEX_DIGITS[value & 0x0F]);
                 }
             }

design_notes.md +6 -13

             # design notes
             ## core model
             - OutgoingRegistry (Variant)
               исходящая конфигурация
               - [provider] configuration
               - [container, live] slots
                 набор вариантов (слотов)
               - [property] primarySlot
             - AssemblyRegistry (Varaint, Slot)
               содержимое слота может быть добавлено после появления слота в OutgoingRegistry
               - assembleTask
                 - inputs
                   - compile unit output (CompileUnit, String)
                   - direct object (task, file collection, etc.)
                 - artifact: directory
               - customTask
                 - artifact: FileSystemLocation
+              - when, all - replayable hooks для получения содержимого сборки
             ## extension
             - adapter
               - whenFinalized
             - dsl
               - variant(name)
                 - slot(name)
                 - from***
               - whenFinalized
               - whenOutgoingConfiguration
               - whenOutgoingSlot
-            outgoing = outgoings.maybeCreate(variant)
+            - ArtifactAssemblyBridge
+              связывает содержимое ArtifactAssembly и исходящей конфигурации OutgoingVariant
-            slot = outgoings.slots.maybeCreate(slotName)
+            - VariantArtifactsHandler
-            assembly = assemblies.register(variantSlot, task, mapOutput)
+              управляет состоянием ArtifactAssembly, используется для DSL сборки
-            outgoing.configure(configuration -> {
+              - configureVariant конфигурирует  VariantArtifactsSpec
  No newline at end of file
-                slots.all(slot -> {
-                    assemblies.when(variant, slot) { assembly ->
-                        configuration.variants.create(slot.name) {
-                            artifact(assembly.artifact)
-                });
-            });
  No newline at end of file

variants/src/main/java/org/implab/gradle/internal/ReplayableQueue.java +3 0

             package org.implab.gradle.internal;
             import java.util.LinkedList;
             import java.util.List;
             import java.util.function.Consumer;
+            import org.eclipse.jdt.annotation.NonNullByDefault;
+            @NonNullByDefault
             public class ReplayableQueue<T> {
                 private final List<Consumer<? super T>> consumers = new LinkedList<>();
                 private final List<T> values = new LinkedList<>();
                 public void add(T value) {
                     consumers.forEach(consumer -> consumer.accept(value));
                     values.add(value);
                 }
                 List<T> values() {
                     return List.copyOf(values);
                 }
                 public void forEach(Consumer<? super T> consumer) {
                     values.forEach(consumer);
                     consumers.add(consumer);
                 }
             }

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

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

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblies.java +12 -10

             package org.implab.gradle.variants.artifacts;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             /**
              * Resolves stateful slot assemblies from cheap slot identities.
              *
              * <p>
              * The returned assembly is a materialized build-model handle. It may expose
              * lazy Gradle providers, but
              * it is no longer an identity object suitable for replayable discovery.
              */
             @NonNullByDefault
             public interface ArtifactAssemblies {
                 /**
                  * Resolves the assembly for the given slot.
                  *
                  * <p>
                  * This call materializes the build-facing body of the slot from its identity.
                  *
                  * @param slot slot identity inside a variant outgoing contract
                  * @return assembly handle for the slot
                  */
                 default ArtifactAssembly require(ArtifactSlot slot) {
                     return find(slot)
                             .orElseThrow(() -> new InvalidUserDataException("Artifact assembly '" + slot + "' isn't registered"));
                 }
                 /**
-                 * Регистрирует обработчик на конкретный слот. Если слот еще не зарегистрирован,
+                 * Registers a configuration action for the assembly of the given slot.
-                 * то обработчик будет добавлен в очередь и будет вызван при регистрации слота.
-                 * Порядок и точный момент вызова обработчиков не определен.
                  *
-                 * @param slot   Слот на который нужно зарегистрировать обработчик
+                 * <p>If the assembly is already registered, the action is invoked immediately.
-                 * @param action Обработчик
+                 * Otherwise, it is queued and invoked when slot materialization registers the
+                 * assembly handle.
+                 *
+                 * @param slot slot identity inside a variant outgoing contract
+                 * @param action assembly configuration action
                  */
                 void when(ArtifactSlot slot, Action<? super ArtifactAssembly> action);
                 /**
-                 * Регистрирует глобальный обработчик, который будет вызван для всех слотов.
+                 * Adds global configuration action for all materialized assemblies. If some assemblies are
-                 * Обработчик будет вызван как для уже зарегистрированных слотов так и для тех,
+                 * already registered, the action will be invoked for them immediately. For assemblies that
-                 * которые будут зарегистрированы в будущем.
+                 * are materialized later, the action will be invoked when they are registered.
                  *
-                 * @param action Обработчик
+                 * @param action assembly configuration action.
                  */
-                void all(Action<? super ArtifactAssembly> action);
+                void configureEach(Action<? super ArtifactAssembly> action);
                 /** Ищет зарегистрированный слот */
                 Optional<ArtifactAssembly> find(ArtifactSlot slot);
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingConfigurationSlotSpec.java +3 -1

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

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariant.java +2 -2

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.provider.Property;
             import org.implab.gradle.variants.core.Variant;
             /**
              * Описывает исходящую конфигурацию варианта
              *
              * Задает связь между моделью вариантов и моделью конфигураций gradle через
              * свойство {@link #getConfiguration()}. Также задает отдельную ось слотов
              * публикации, но не задает правил связывания этих слотов с самой конфигурацией
              * и их содержимым. Самый простой вариант это {@link ArtifactAssemblies}.
              */
             public interface OutgoingVariant {
                 /**
                  * Исходный вариант для которого строится Outgoing конфигурация
                  */
                 Variant getVariant();
                 /**
                  * Провайдер зарегистрированной конфигурации
                  */
-                NamedDomainObjectProvider<Configuration> getConfiguration();
+                NamedDomainObjectProvider<? extends Configuration> getConfiguration();
-                default void configure(Action<? super Configuration> action) {
+                default void configureOutgoing(Action<? super Configuration> action) {
                     getConfiguration().configure(action);
                 }
                 /**
                  * Слоты конфигурации, данная коллекция живая, используется для
                  * получения информации об объявленных слотах, но эти слоты не
                  * обязаны быть сконфигурированы, т.е. это только Identity.
                  *
                  * @see {@link ArtifactSlot}
                  */
                 NamedDomainObjectContainer<Slot> getSlots();
                 /**
                  * Основной набор артефактов (primary variant) для исходящей конфигурации
                  *
                  * <p>
                  * Если в свойстве {@link #getSlots()} есть только один слой, то по конвенции он
                  * считается также основным.
                  */
                 Property<Slot> getPrimarySlot();
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariantsContext.java +7 -9

             package org.implab.gradle.variants.artifacts;
             import java.util.Optional;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.variants.core.Variant;
-            import org.implab.gradle.variants.core.VariantsView;
             /**
              * Контекст работы с вариантами публикации, становится доступным после
              * финализации модели вариантов. Фактически является живой моделью
              */
             public interface OutgoingVariantsContext {
-                /**
+                ArtifactAssemblies getAssemblies();
-                 * Зафиксированное представление о вариантах на основе которого адаптеры могут
-                 * конфигурировать артефакты и исходящие конфигурации
-                 */
-                VariantsView getVariants();
-                ArtifactAssemblies getAssemblies();
+                void configureVariant(Variant variant, Action<? super VariantArtifactsSpec> action);
                 /**
                  * Replayable hook для всех объявленных конфигураций
                  */
-                void all(Action<? super OutgoingVariant> action);
+                void configureEach(Action<? super OutgoingVariant> action);
                 Optional<OutgoingVariant> findOutgoing(Variant variant);
                 default OutgoingVariant requireOutgoing(Variant variant) {
                     return findOutgoing(variant)
                             .orElseThrow(() -> new InvalidUserDataException("Outgoing variant '" + variant + "' isn't registered"));
                 }
-                ArtifactAssemblyRules slotRules(ArtifactSlot slot);
+                void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action);
+                void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action);
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsExtension.java +17 -12

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Action;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             /**
              * Project-level DSL entry point for declaring outgoing artifacts per variant.
              *
-             * <p>A variant represents one external outgoing contract. Slots declared inside a variant represent
+             * <p>
-             * artifact sets within that contract. One slot is expected to materialize to one published artifact.
+             * A variant represents one external outgoing contract. Slots declared inside a
+             * variant represent
+             * artifact sets within that contract. One slot is expected to materialize to
+             * one published artifact.
              */
             public interface VariantArtifactsExtension {
                 /**
                  * Configures artifact slots of the named variant.
                  *
                  * @param variantName variant name
-                 * @param action variant artifact declaration
+                 * @param action      variant artifact declaration
                  */
                 void variant(String variantName, Action<? super VariantArtifactsSpec> action);
                 default void variant(String variantName, Closure<?> closure) {
                     variant(variantName, Closures.action(closure));
                 }
                 /**
-                 * Registers a callback invoked with the finalized artifact model.
+                 * Registers a callback invoked when the outgoing variants context becomes
+                 * available.
                  *
-                 * @param action finalized-model callback
+                 * @param action outgoing variants context callback
                  */
-                void whenFinalized(Action<? super OutgoingVariantsContext> action);
+                void whenAvailable(Action<? super OutgoingVariantsContext> action);
-                default void whenFinalized(Closure<?> closure) {
+                default void whenAvailable(Closure<?> closure) {
-                    whenFinalized(Closures.action(closure));
+                    whenAvailable(Closures.action(closure));
                 }
                 /**
-                 * Registers a callback invoked for each materialized root outgoing configuration.
+                 * Registers a callback invoked for each materialized root outgoing
+                 * configuration.
                  *
                  * @param action variant-level outgoing configuration callback
                  */
-                void whenOutgoingVariant(Action<? super OutgoingConfigurationSpec> action);
+                void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action);
-                default void whenOutgoingVariant(Closure<?> closure) {
+                default void whenOutgoingConfiguration(Closure<?> closure) {
-                    whenOutgoingVariant(Closures.action(closure));
+                    whenOutgoingConfiguration(Closures.action(closure));
                 }
                 /**
                  * Registers a callback invoked for each materialized outgoing slot publication.
                  *
                  * @param action slot-level outgoing publication callback
                  */
                 void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action);
                 default void whenOutgoingSlot(Closure<?> closure) {
                     whenOutgoingSlot(Closures.action(closure));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyBinder.java ~~variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyBridge.java~~ renamed +5 -3

             package org.implab.gradle.variants.artifacts.internal;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblies;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
             /**
              * Связывает описание исходящих конфигураций gradle и сборку содержимого слотов
              * из {@link ArtifactAssemblies}
              */
             @NonNullByDefault
-            public class ArtifactAssemblyBridge implements Action<OutgoingVariant> {
+            public class ArtifactAssemblyBinder implements Action<OutgoingVariant> {
                 private final ArtifactAssemblies resolver;
-                public ArtifactAssemblyBridge(ArtifactAssemblies resolver) {
+                public ArtifactAssemblyBinder(ArtifactAssemblies resolver) {
                     this.resolver = resolver;
                 }
                 @Override
                 public void execute(OutgoingVariant outgoingVariant) {
                     var slots = outgoingVariant.getSlots();
                     var primarySlotProvider = outgoingVariant.getPrimarySlot();
                     var variant = outgoingVariant.getVariant();
                     // связываем конфигурацию
-                    outgoingVariant.configure(configuration -> {
+                    outgoingVariant.configureOutgoing(configuration -> {
                         var primarySlot = primarySlotProvider.get();
                         var outgoing = configuration.getOutgoing();
                         // связываем основной вариант конфигурации
                         resolver.when(
                                 new ArtifactSlot(variant, primarySlot),
                                 assembly -> outgoing.artifact(assembly.getArtifact()));
                         // для всех объявленных слотов
                         slots.all(slot -> {
                             // кроме основного
                             if (slot.equals(primarySlot))
                                 return;
                             // связываем артефакты
                             resolver.when(
                                     new ArtifactSlot(variant, slot),
                                     assembly -> outgoing.getVariants()
                                             .register(slot.getName())
                                             .configure(cv -> cv.artifact(assembly.getArtifact())));
                         });
                     });
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyRegistry.java ~~variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblyRegistry.java~~ renamed +5 -2

-            package org.implab.gradle.variants.artifacts;
+            package org.implab.gradle.variants.artifacts.internal;
             import java.util.LinkedHashMap;
             import java.util.Map;
             import java.util.Optional;
             import java.util.function.Function;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Task;
             import org.gradle.api.file.FileSystemLocation;
             import org.gradle.api.provider.Provider;
             import org.gradle.api.tasks.TaskProvider;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.internal.ReplayableQueue;
+            import org.implab.gradle.variants.artifacts.ArtifactAssemblies;
+            import org.implab.gradle.variants.artifacts.ArtifactAssembly;
+            import org.implab.gradle.variants.artifacts.ArtifactSlot;
             @NonNullByDefault
             public class ArtifactAssemblyRegistry implements ArtifactAssemblies {
                 private final Map<ArtifactSlot, Deferred<ArtifactAssembly>> assembliesBySlots = new LinkedHashMap<>();
                 private final ReplayableQueue<ArtifactAssembly> assemblies = new ReplayableQueue<>();
                 public ArtifactAssemblyRegistry() {
                 }
                 public <T extends Task> ArtifactAssembly register(
                         ArtifactSlot slot,
                         TaskProvider<T> task,
                         Function<? super T, ? extends Provider<? extends FileSystemLocation>> mapOutputArtifact) {
                     var deferred = getDeferred(slot);
                     if (deferred.resolved()) {
                         throw new InvalidUserDataException("Artifact assembly '" + slot + "' is already registered");
                     }
                     var outputArtifact = task.flatMap(mapOutputArtifact::apply);
                     var assembly = new Assembly(outputArtifact, task);
                     deferred.resolve(assembly);
                     assemblies.add(assembly);
                     return assembly;
                 }
                 @Override
                 public Optional<ArtifactAssembly> find(ArtifactSlot slot) {
                     // to prevent creation of map entries on lookup use the map directly
                     var deferred = assembliesBySlots.get(slot);
                     return deferred != null && deferred.resolved()
                             ? Optional.of(deferred.value())
                             : Optional.empty();
                 }
                 @Override
                 public void when(ArtifactSlot slot, Action<? super ArtifactAssembly> action) {
                     getDeferred(slot).whenResolved(action::execute);
                 }
                 @Override
-                public void all(Action<? super ArtifactAssembly> action) {
+                public void configureEach(Action<? super ArtifactAssembly> action) {
                     assemblies.forEach(action::execute);
                 }
                 private Deferred<ArtifactAssembly> getDeferred(ArtifactSlot slot) {
                     return assembliesBySlots.computeIfAbsent(slot, k -> new Deferred<>());
                 }
                 static class Assembly implements ArtifactAssembly {
                     private final Provider<? extends FileSystemLocation> artifact;
                     private final TaskProvider<? extends Task> task;
                     Assembly(Provider<? extends FileSystemLocation> artifact, TaskProvider<? extends Task> task) {
                         this.artifact = artifact;
                         this.task = task;
                     }
                     @Override
                     public Provider<? extends FileSystemLocation> getArtifact() {
                         return artifact;
                     }
                     @Override
                     public TaskProvider<? extends Task> getAssemblyTask() {
                         return task;
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultArtifactAssemblySpec.java +2 0

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.HashSet;
             import java.util.Set;
             import java.util.function.Consumer;
             import java.util.stream.Stream;
+            import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.core.lang.Strings;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.artifacts.OutputSelectionSpec;
             /**
              * Реализация DSL модели, строит набор {@link SlotContribution}. При построении набора
              * правила и корректность не проверяются. По окончании использования клиент
              * вызывает метод {@link #process(Consumer)} для обработки результатов.
              *
              */
+            @NonNullByDefault
             final class DefaultArtifactAssemblySpec implements ArtifactAssemblySpec {
                 private final Consumer<? super SlotContribution> consumer;
                 private final ObjectFactory objectFactory;
                 DefaultArtifactAssemblySpec(ObjectFactory objectFactory, Consumer<? super SlotContribution> consumer) {
                     this.consumer = consumer;
                     this.objectFactory = objectFactory;
                 }
                 @Override
                 public void from(Object artifact) {
                     consumer.accept(new DirectContribution(artifact));
                 }
                 @Override
                 public void fromVariant(Action<? super OutputSelectionSpec> action) {
                     consumer.accept(new VariantOutputsContribution(outputs(action)));
                 }
                 @Override
                 public void fromRole(String roleName, Action<? super OutputSelectionSpec> action) {
                     consumer.accept(new RoleOutputsContribution(
                             objectFactory.named(Role.class, roleName),
                             outputs(action)));
                 }
                 @Override
                 public void fromLayer(String layerName, Action<? super OutputSelectionSpec> action) {
                     consumer.accept(new LayerOutputsContribution(
                             objectFactory.named(Layer.class, layerName),
                             outputs(action)));
                 }
                 private static Set<String> outputs(Action<? super OutputSelectionSpec> action) {
                     var spec = new OutputsSetSpec();
                     action.execute(spec);
                     return spec.outputs();
                 }
                 private static class OutputsSetSpec implements OutputSelectionSpec {
                     private final Set<String> outputs = new HashSet<>();
                     @Override
                     public void output(String name, String... extra) {
                         Stream.concat(Stream.of(name), Stream.of(extra))
                             .map(Strings::requireNonBlank)
                             .forEach(outputs::add);
                     }
                     Set<String> outputs() {
                         return Set.copyOf(outputs);
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/OutgoingRegistry.java +86 -21

@@ -1,56 +1,121
1	package org.implab.gradle.variants.artifacts.internal;	1	package org.implab.gradle.variants.artifacts.internal;
2		2
3	import java.util.LinkedHashMap;	3	import java.util.LinkedHashMap;
4	import java.util.LinkedList;
5	import java.util.List;
6	import java.util.Map;	4	import java.util.Map;
7	import java.util.Optional;	5	import java.util.Optional;
		6	import java.util.Set;
8	import java.util.function.Consumer;	7	import java.util.function.Consumer;
9		8
		9	import org.eclipse.jdt.annotation.NonNullByDefault;
		10	import org.gradle.api.InvalidUserDataException;
		11	import org.gradle.api.NamedDomainObjectContainer;
		12	import org.gradle.api.NamedDomainObjectProvider;
		13	import org.gradle.api.artifacts.Configuration;
10	import org.gradle.api.artifacts.ConfigurationContainer;	14	import org.gradle.api.artifacts.ConfigurationContainer;
11	import org.gradle.api.model.ObjectFactory;	15	import org.gradle.api.model.ObjectFactory;
12	import org.gradle.api.provider.Pro~~viderFactor~~y;	16	import org.gradle.api.provider.Property;
		17	import org.implab.gradle.internal.ReplayableQueue;
13	import org.implab.gradle.variants.artifacts.OutgoingVariant;	18	import org.implab.gradle.variants.artifacts.OutgoingVariant;
		19	import org.implab.gradle.variants.artifacts.Slot;
14	import org.implab.gradle.variants.core.Variant;	20	import org.implab.gradle.variants.core.Variant;
15		21
		22	/**
		23	* Реестр исходящих вариантов. Связывает исходящие конфигурации с вариантами
		24	* сборки. Связь устанавливается 1:1.
		25	*/
		26	@NonNullByDefault
16	public class OutgoingRegistry {	27	public class OutgoingRegistry {
17	private final Map<Variant, ~~Default~~Outgoing~~Configuration~~> outgoingByVariant = new LinkedHashMap<>();	28	private final Map<Variant, OutgoingVariant> outgoingByVariant = new LinkedHashMap<>();
18	private final List<Consumer<? super DefaultOutgoingConfiguration>> hooks = new LinkedList<>();	29	private final ReplayableQueue<OutgoingVariant> outgoingVariants = new ReplayableQueue<>();
19
20	private final ConfigurationContainer configurations;	30	private final ConfigurationContainer configurations;
21	private final ObjectFactory objects;	31	private final ObjectFactory objects;
22	private final ProviderFactory providers;	32	private final Set<Variant> declaredVariants;
23		33
24	public OutgoingRegistry(ConfigurationContainer configurations, ObjectFactory objects, ProviderFactory providers) {	34	public OutgoingRegistry(
		35	ConfigurationContainer configurations,
		36	ObjectFactory objects,
		37	Set<Variant> declaredVariants) {
25	this.configurations = configurations;	38	this.configurations = configurations;
26	this.objects = objects;	39	this.objects = objects;
27	this.providers = providers;	40	this.declaredVariants = declaredVariants;
28	}	41	}
29		42
30	public Optional<OutgoingVariant> find~~Outgoing~~(Variant variant) {	43	public Optional<OutgoingVariant> find(Variant variant) {
31	return Optional.ofNullable(outgoingByVariant.get(variant));	44	return Optional.ofNullable(outgoingByVariant.get(variant));
32	}	45	}
33		46
34	public OutgoingVariant maybeCreate(Variant variant) {	47	public OutgoingVariant maybeCreate(Variant variant) {
35	var outgoing = outgoingByVariant.computeIfAbsent(variant, this::newOutgoingConfiguration);	48	return find(variant).orElseGet(() -> create(variant));
36	hooks.forEach(hook -> hook.accept(outgoing));	49	}
		50
		51	public OutgoingVariant create(Variant variant) {
		52	if (!declaredVariants.contains(variant))
		53	throw new InvalidUserDataException("Variant " + variant + " isn't declared");
		54	if (outgoingByVariant.containsKey(variant))
		55	throw new InvalidUserDataException("Outgoing variant " + variant + " already exists");
		56
		57	var configuration = configurations.consumable(outgoingConfigurationName(variant));
		58	var outgoing = new Outgoing(variant, configuration);
		59
		60	outgoingByVariant.put(variant, outgoing);
		61
		62	outgoingVariants.add(outgoing);
		63
37	return outgoing;	64	return outgoing;
38	}	65	}
39		66
40	public void all(Consumer<? super OutgoingVariant> action) {	67	/**
41	outgoingByVariant.values().forEach(action);	68	* Replayable hook which is applied when an outgoing variant is defined
42	hooks.add(action);	69	*
43	}	70	* @param action
44		71	*/
45	private DefaultOutgoingConfiguration newOutgoingConfiguration(Variant variant) {	72	public void configureEach(Consumer<? super OutgoingVariant> action) {
46	var configuration = configurations.register(outgoingConfigurationName(variant));	73	outgoingVariants.forEach(action);
47
48	return new DefaultOutgoingConfiguration(variant, configuration, objects, providers);
49	}	74	}
50		75
51	private String outgoingConfigurationName(Variant variant) {	76	private String outgoingConfigurationName(Variant variant) {
52	return variant.getName() + "Elements";	77	return variant.getName() + "Elements";
53	}	78	}
54		79
		80	private class Outgoing implements OutgoingVariant {
		81
		82	private final Variant variant;
		83
		84	private final NamedDomainObjectProvider<? extends Configuration> configurationProvider;
		85
		86	private final NamedDomainObjectContainer<Slot> slots;
		87
		88	private final Property<Slot> primarySlot;
		89
		90	public Outgoing(
		91	Variant variant,
		92	NamedDomainObjectProvider<? extends Configuration> configurationProvider) {
		93	this.variant = variant;
		94	this.configurationProvider = configurationProvider;
		95	this.slots = objects.domainObjectContainer(Slot.class);
		96	this.primarySlot = objects.property(Slot.class);
		97	primarySlot.finalizeValueOnRead();
		98	}
		99
		100	@Override
		101	public Property<Slot> getPrimarySlot() {
		102	return primarySlot;
		103	}
		104
		105	@Override
		106	public Variant getVariant() {
		107	return variant;
		108	}
		109
		110	@Override
		111	public NamedDomainObjectProvider<? extends Configuration> getConfiguration() {
		112	return configurationProvider;
		113	}
		114
		115	@Override
		116	public NamedDomainObjectContainer<Slot> getSlots() {
		117	return slots;
		118	}
		119	}
55		120
56	}	121	}

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

             package org.implab.gradle.variants.artifacts.internal;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             @NonNullByDefault
-            public interface SlotContribution {
+            interface SlotContribution {
                 void accept(SlotContributionVisitor visitor);
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/SlotContributionVisitor.java +3 -5

             package org.implab.gradle.variants.artifacts.internal;
-            import java.util.function.Consumer;
+            import org.eclipse.jdt.annotation.NonNullByDefault;
-            public interface SlotContributionVisitor {
+            @NonNullByDefault
+            interface SlotContributionVisitor {
                 void visit(DirectContribution contribution);
                 void visit(VariantOutputsContribution contribution);
                 void visit(RoleOutputsContribution contribution);
                 void visit(LayerOutputsContribution contribution);
-                default Consumer<SlotContribution> consumer() {
-                    return slot -> slot.accept(this);
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblyRules.java removed 0 -19

NO CONTENT: file was removed

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactConfigurationHandler.java removed 0 -100

NO CONTENT: file was removed

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultOutgoingConfiguration.java removed 0 -62

NO CONTENT: file was removed

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultVariantArtifactSpec.java removed 0 -51

NO CONTENT: file was removed

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/SlotInputsAssembler.java removed 0 -96

	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