implab/gradle-common Commit - r46:f260d19f1118

WIP working on variants api

cin -

r46:f260d19f1118 default

parent child

Context file:

r46:f260d19f1118

Expand all files

variants/src/main/java/org/implab/gradle/variants/VariantArtifactsPlugin.java created 644 +29 0

@@ -0,0 +1,29
	1	package org.implab.gradle.variants;
	2
	3	import org.gradle.api.Plugin;
	4	import org.gradle.api.Project;
	5	import org.implab.gradle.common.core.lang.Deferred;
	6	import org.implab.gradle.variants.artifacts.VariantArtifactsContext;
	7	import org.implab.gradle.variants.core.VariantsExtension;
	8
	9	public abstract class VariantArtifactsPlugin implements Plugin<Project> {
	10
	11	@Override
	12	public void apply(Project target) {
	13	var extensions = target.getExtensions();
	14
	15	// Apply the main VariantsPlugin to ensure the core variant model is available.
	16	target.getPlugins().apply(VariantsPlugin.class);
	17	// Access the VariantsExtension to configure variant sources.
	18	var variantsExtension = extensions.getByType(VariantsExtension.class);
	19
	20	var deferred = new Deferred<VariantArtifactsContext>();
	21
	22	variantsExtension.whenFinalized(variants -> {
	23
	24	});
	25
	26
	27	}
	28
	29	}

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblies.java created 644 +22 0

@@ -0,0 +1,22
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.eclipse.jdt.annotation.NonNullByDefault;
	4
	5	/**
	6	* Resolves stateful slot assemblies from cheap slot identities.
	7	*
	8	* <p>The returned assembly is a materialized build-model handle. It may expose lazy Gradle providers, but
	9	* it is no longer an identity object suitable for replayable discovery.
	10	*/
	11	@NonNullByDefault
	12	public interface ArtifactAssemblies {
	13	/**
	14	* Resolves the assembly for the given slot.
	15	*
	16	* <p>This call materializes the build-facing body of the slot from its identity.
	17	*
	18	* @param slot slot identity inside a variant outgoing contract
	19	* @return assembly handle for the slot
	20	*/
	21	ArtifactAssembly resolveSlot(ArtifactSlot slot);
	22	}

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssembly.java created 644 +32 0

@@ -0,0 +1,32
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.gradle.api.Task;
	4	import org.gradle.api.file.FileSystemLocation;
	5	import org.gradle.api.provider.Provider;
	6	import org.gradle.api.tasks.TaskProvider;
	7
	8	/**
	9	* Materialized body of an {@link ArtifactSlot}.
	10	*
	11	* <p>An assembly is a stateful build object obtained on demand from
	12	* {@link ArtifactAssemblies#resolveSlot(ArtifactSlot)}. It describes how the slot artifact is produced and
	13	* where that single published artifact will appear.
	14	*/
	15	public interface ArtifactAssembly {
	16
	17	/**
	18	* Returns the published artifact produced for the slot.
	19	*
	20	* <p>A slot is expected to produce exactly one artifact represented by one file or one directory.
	21	*
	22	* @return provider of the produced artifact location
	23	*/
	24	Provider<? extends FileSystemLocation> getArtifact();
	25
	26	/**
	27	* Returns the task that assembles the slot artifact.
	28	*
	29	* @return provider of the assembly task
	30	*/
	31	TaskProvider<? extends Task> getAssemblyTask();
	32	}

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblySpec.java created 644 +60 0

@@ -0,0 +1,60
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.gradle.api.Action;
	4	import groovy.lang.Closure;
	5	import org.implab.gradle.common.core.lang.Closures;
	6
	7	/**
	8	* DSL model describing how a slot artifact is assembled.
	9	*
	10	* <p>Selection rules declared here may refer to internal build topology such as roles, layers or units.
	11	* Those selectors influence slot assembly only and do not become part of published artifact identity.
	12	*
	13	* <p>Regardless of the number of declared inputs, a slot is expected to materialize to a single published
	14	* artifact.
	15	*/
	16	public interface ArtifactAssemblySpec {
	17	/**
	18	* Contributes direct input material to the slot assembly.
	19	*
	20	* <p>The resulting slot still represents one published artifact.
	21	*
	22	* @param artifact direct input notation understood by the implementation
	23	*/
	24	void from(Object artifact);
	25
	26	/**
	27	* Selects outputs from the whole variant scope.
	28	*
	29	* @param action output selection rule
	30	*/
	31	void fromVariant(Action<? super OutputSelectionSpec> action);
	32
	33	default void fromVariant(Closure<?> closure) {
	34	fromVariant(Closures.action(closure));
	35	}
	36
	37	/**
	38	* Selects outputs from a role inside the current variant.
	39	*
	40	* @param roleName role name used only for assembly-time selection
	41	* @param action output selection rule
	42	*/
	43	void fromRole(String roleName, Action<? super OutputSelectionSpec> action);
	44
	45	default void fromRole(String roleName, Closure<?> closure) {
	46	fromRole(roleName, Closures.action(closure));
	47	}
	48
	49	/**
	50	* Selects outputs from a layer inside the current variant.
	51	*
	52	* @param layerName layer name used only for assembly-time selection
	53	* @param action output selection rule
	54	*/
	55	void fromLayer(String layerName, Action<? super OutputSelectionSpec> action);
	56
	57	default void fromLayer(String layerName, Closure<?> closure) {
	58	fromLayer(layerName, Closures.action(closure));
	59	}
	60	}

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactSlot.java created 644 +14 0

@@ -0,0 +1,14
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.implab.gradle.variants.core.Variant;
	4
	5	/**
	6	* Identity of a published artifact slot inside a variant outgoing contract.
	7	*
	8	* <p>This is a cheap immutable identity object suitable for discovery and selection. Heavy build state is
	9	* obtained separately through {@link ArtifactAssemblies}.
	10	*
	11	* @param variant variant owning the outgoing contract
	12	* @param slot slot identity inside the variant
	13	*/
	14	public record ArtifactSlot(Variant variant, Slot slot) {}

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactSlotsView.java created 644 +48 0

@@ -0,0 +1,48
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import java.util.Optional;
	4	import java.util.Set;
	5
	6	import org.implab.gradle.variants.core.Variant;
	7
	8	/**
	9	* Finalized view of artifact slot identities.
	10	*
	11	* <p>This view exposes only cheap slot identities. Assemblies and publication state are resolved
	12	* separately.
	13	*/
	14	public interface ArtifactSlotsView {
	15	/**
	16	* Returns all declared slot identities.
	17	*
	18	* @return all slots known to the finalized model
	19	*/
	20	Set<ArtifactSlot> getSlots();
	21
	22	/**
	23	* Returns all slots declared for the given variant.
	24	*
	25	* @param variant variant identity
	26	* @return slots declared for the variant
	27	*/
	28	Set<ArtifactSlot> getSlotsForVariant(Variant variant);
	29
	30	/**
	31	* Finds a slot by typed identities.
	32	*
	33	* @param variant variant identity
	34	* @param slot slot identity inside the variant
	35	* @return matching slot when present
	36	*/
	37	Optional<ArtifactSlot> findSlot(Variant variant, Slot slot);
	38
	39	/**
	40	* Requires a slot by typed identities.
	41	*
	42	* @param variant variant identity
	43	* @param slot slot identity inside the variant
	44	* @return matching slot
	45	*/
	46	ArtifactSlot requireSlot(Variant variant, Slot slot);
	47
	48	}

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingArtifactSlotSpec.java created 644 +59 0

@@ -0,0 +1,59
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.Task;
	5	import org.gradle.api.attributes.AttributeContainer;
	6	import groovy.lang.Closure;
	7	import org.implab.gradle.common.core.lang.Closures;
	8
	9	/**
	10	* Materialized outgoing publication state of a single slot.
	11	*
	12	* <p>This type is a DSL facade to represent already created publication-facing state. Slot-specific
	13	* publication tweaks should be applied here rather than through {@link OutgoingVariantSpec}, which
	14	* is limited to the root outgoing configuration of the variant.
	15	*/
	16	public interface OutgoingArtifactSlotSpec {
	17	/**
	18	* Returns the published slot identity.
	19	*
	20	* @return slot identity
	21	*/
	22	ArtifactSlot getArtifactSlot();
	23
	24	/**
	25	* Returns the assembly backing the published slot.
	26	*
	27	* @return slot assembly
	28	*/
	29	ArtifactAssembly getAssembly();
	30
	31	/**
	32	* Returns whether this slot is the primary outgoing artifact set of the variant.
	33	*
	34	* @return {@code true} for the primary slot
	35	*/
	36	boolean isPrimary();
	37
	38	/**
	39	* Configures the task producing the slot artifact.
	40	*
	41	* @param action task configuration action
	42	*/
	43	void assemblyTask(Action<? super Task> action);
	44
	45	default void assemblyTask(Closure<?> closure) {
	46	assemblyTask(Closures.action(closure));
	47	}
	48
	49	/**
	50	* Configures attributes of this slot publication.
	51	*
	52	* @param action artifact attribute configuration action
	53	*/
	54	void artifactAttributes(Action<? super AttributeContainer> action);
	55
	56	default void artifactAttributes(Closure<?> closure) {
	57	artifactAttributes(Closures.action(closure));
	58	}
	59	}

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariantSpec.java created 644 +43 0

@@ -0,0 +1,43
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.artifacts.Configuration;
	5	import org.implab.gradle.common.core.lang.Closures;
	6	import org.implab.gradle.variants.core.Variant;
	7
	8	import groovy.lang.Closure;
	9
	10	/**
	11	* Materialized root outgoing configuration of a variant.
	12	*
	13	* <p>This is a variant-level publication hook. Slot-specific publication state is exposed separately via
	14	* {@link OutgoingArtifactSlotSpec}.
	15	*/
	16	public interface OutgoingVariantSpec {
	17	/**
	18	* Returns the variant whose outgoing configuration is represented here.
	19	*
	20	* @return variant identity
	21	*/
	22	Variant getVariant();
	23
	24	/**
	25	* Returns the root consumable outgoing configuration of the variant.
	26	*
	27	* @return outgoing configuration
	28	*/
	29	Configuration getConfiguration();
	30
	31	/**
	32	* Applies a configuration action to the root outgoing configuration.
	33	*
	34	* @param action configuration action
	35	*/
	36	default void configuration(Action<? super Configuration> action) {
	37	action.execute(getConfiguration());
	38	}
	39
	40	default void configuration(Closure<?> closure) {
	41	configuration(Closures.action(closure));
	42	}
	43	}

variants/src/main/java/org/implab/gradle/variants/artifacts/OutputSelectionSpec.java created 644 +24 0

@@ -0,0 +1,24
	1	package org.implab.gradle.variants.artifacts;
	2
	3	/**
	4	* DSL model for selecting named outputs from a chosen source scope.
	5	*
	6	* <p>The selected outputs are inputs to slot assembly. They do not create additional outgoing slots or
	7	* affect slot identity.
	8	*/
	9	public interface OutputSelectionSpec {
	10	/**
	11	* Selects one named output.
	12	*
	13	* @param name output name
	14	*/
	15	void output(String name);
	16
	17	/**
	18	* Selects several named outputs.
	19	*
	20	* @param name first output name
	21	* @param extra additional output names
	22	*/
	23	void output(String name, String... extra);
	24	}

variants/src/main/java/org/implab/gradle/variants/artifacts/Slot.java created 644 +12 0

@@ -0,0 +1,12
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.gradle.api.Named;
	4
	5	/**
	6	* Named identity of a slot inside a variant outgoing contract.
	7	*
	8	* <p>A slot does not identify a published artifact on its own. Combine it with a variant to obtain an
	9	* {@link ArtifactSlot}.
	10	*/
	11	public interface Slot extends Named {
	12	}

variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsConfiguration.java created 644 +28 0

@@ -0,0 +1,28
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.gradle.api.NamedDomainObjectContainer;
	4	import org.gradle.api.NamedDomainObjectProvider;
	5	import org.gradle.api.artifacts.Configuration;
	6	import org.implab.gradle.variants.core.Variant;
	7
	8	/** Описывает конфигурация варианта исходящей конфигурации */
	9	public interface VariantArtifactsConfiguration {
	10	/**
	11	* Исходный вариант для которого строится Outgoing конфигурация
	12	*/
	13	Variant getVariant();
	14
	15	/**
	16	* Провайдер зарегистрированной конфигурации
	17	*/
	18	NamedDomainObjectProvider<Configuration> getOutgoingConfiguration();
	19
	20	/**
	21	* Слоты конфигурации, данная коллекция живая, используется для
	22	* получения информации об объявленных слотах, но эти слоты не
	23	* обязаны быть сконфигурированы, т.е. это только Identity.
	24	*
	25	* @see {@link ArtifactSlot}
	26	*/
	27	NamedDomainObjectContainer<Slot> getSlots();
	28	}

variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsContext.java created 644 +27 0

@@ -0,0 +1,27
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import java.util.Optional;
	4
	5	import org.gradle.api.Action;
	6	import org.implab.gradle.variants.core.Variant;
	7	import org.implab.gradle.variants.core.VariantsView;
	8
	9	/**
	10	* Контекст работы с вариантами публикации, становится доступным после
	11	* финализации модели вариантов. Фактически является живой моделью
	12	*/
	13	public interface VariantArtifactsContext {
	14
	15	/**
	16	* Зафиксированное представление о вариантах на основе которого адаптеры могут
	17	* конфигурировать артефакты и исходящие конфигурации
	18	*/
	19	VariantsView getVariants();
	20
	21	void all(Action<? super VariantArtifactsConfiguration> action);
	22
	23	Optional<VariantArtifactsConfiguration> findArtifacts(Variant variant);
	24
	25	VariantArtifactsConfiguration requireArtifacts(Variant variant);
	26
	27	}

variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsExtension.java created 644 +59 0

@@ -0,0 +1,59
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.gradle.api.Action;
	4	import org.implab.gradle.common.core.lang.Closures;
	5
	6	import groovy.lang.Closure;
	7
	8	/**
	9	* Project-level DSL entry point for declaring outgoing artifacts per variant.
	10	*
	11	* <p>A variant represents one external outgoing contract. Slots declared inside a variant represent
	12	* artifact sets within that contract. One slot is expected to materialize to one published artifact.
	13	*/
	14	public interface VariantArtifactsExtension {
	15	/**
	16	* Configures artifact slots of the named variant.
	17	*
	18	* @param variantName variant name
	19	* @param action variant artifact declaration
	20	*/
	21	void variant(String variantName, Action<? super VariantArtifactsSpec> action);
	22
	23	default void variant(String variantName, Closure<?> closure) {
	24	variant(variantName, Closures.action(closure));
	25	}
	26
	27	/**
	28	* Registers a callback invoked with the finalized artifact model.
	29	*
	30	* @param action finalized-model callback
	31	*/
	32	void whenFinalized(Action<? super VariantArtifactsContext> action);
	33
	34	default void whenFinalized(Closure<?> closure) {
	35	whenFinalized(Closures.action(closure));
	36	}
	37
	38	/**
	39	* Registers a callback invoked for each materialized root outgoing configuration.
	40	*
	41	* @param action variant-level outgoing configuration callback
	42	*/
	43	void whenOutgoingVariant(Action<? super OutgoingVariantSpec> action);
	44
	45	default void whenOutgoingVariant(Closure<?> closure) {
	46	whenOutgoingVariant(Closures.action(closure));
	47	}
	48
	49	/**
	50	* Registers a callback invoked for each materialized outgoing slot publication.
	51	*
	52	* @param action slot-level outgoing publication callback
	53	*/
	54	void whenOutgoingSlot(Action<? super OutgoingArtifactSlotSpec> action);
	55
	56	default void whenOutgoingSlot(Closure<?> closure) {
	57	whenOutgoingSlot(Closures.action(closure));
	58	}
	59	}

variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsSpec.java created 644 +40 0

@@ -0,0 +1,40
	1	package org.implab.gradle.variants.artifacts;
	2
	3	import org.gradle.api.Action;
	4	import groovy.lang.Closure;
	5	import org.implab.gradle.common.core.lang.Closures;
	6
	7	/**
	8	* DSL model for declaring slots of a single variant.
	9	*
	10	* <p>The surrounding variant defines the external outgoing contract. Slots declared here define artifact
	11	* sets within that contract. If a variant exposes more than one slot, one of them is expected to be the
	12	* primary slot.
	13	*/
	14	public interface VariantArtifactsSpec {
	15	/**
	16	* Declares a non-primary slot of the current variant.
	17	*
	18	* @param name slot name
	19	* @param action slot declaration
	20	* @return slot identity
	21	*/
	22	Slot slot(String name, Action<? super ArtifactAssemblySpec> action);
	23
	24	default Slot slot(String name, Closure<?> closure) {
	25	return slot(name, Closures.action(closure));
	26	}
	27
	28	/**
	29	* Declares the primary slot of the current variant.
	30	*
	31	* @param name slot name
	32	* @param action slot declaration
	33	* @return slot identity
	34	*/
	35	Slot primarySlot(String name, Action<? super ArtifactAssemblySpec> action);
	36
	37	default Slot primarySlot(String name, Closure<?> closure) {
	38	return primarySlot(name, Closures.action(closure));
	39	}
	40	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultVariantArtifactsContext.java created 644 +37 0

@@ -0,0 +1,37
	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.VariantArtifactsConfiguration;
	7	import org.implab.gradle.variants.artifacts.VariantArtifactsContext;
	8	import org.implab.gradle.variants.core.Variant;
	9	import org.implab.gradle.variants.core.VariantsView;
	10
	11	public class DefaultVariantArtifactsContext implements VariantArtifactsContext {
	12
	13	@Override
	14	public VariantsView getVariants() {
	15	// TODO Auto-generated method stub
	16	throw new UnsupportedOperationException("Unimplemented method 'getVariants'");
	17	}
	18
	19	@Override
	20	public void all(Action<? super VariantArtifactsConfiguration> action) {
	21	// TODO Auto-generated method stub
	22	throw new UnsupportedOperationException("Unimplemented method 'all'");
	23	}
	24
	25	@Override
	26	public Optional<VariantArtifactsConfiguration> findArtifacts(Variant variant) {
	27	// TODO Auto-generated method stub
	28	throw new UnsupportedOperationException("Unimplemented method 'findArtifacts'");
	29	}
	30
	31	@Override
	32	public VariantArtifactsConfiguration requireArtifacts(Variant variant) {
	33	// TODO Auto-generated method stub
	34	throw new UnsupportedOperationException("Unimplemented method 'requireArtifacts'");
	35	}
	36
	37	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/VariantArtifactsRegistry.java created 644 +11 0

@@ -0,0 +1,11
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import org.gradle.api.Action;
	4	import org.implab.gradle.variants.artifacts.VariantArtifactsSpec;
	5	import org.implab.gradle.variants.core.Variant;
	6
	7	public class VariantArtifactsRegistry {
	8	public void configureVariant(Variant variant, Action<? super VariantArtifactsSpec> action) {
	9
	10	}
	11	}

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

@@ -0,0 +1,41
	1	/**
	2	* Variant-scoped outgoing artifacts.
	3	*
	4	* <p>This package models the external artifact contract of a project in terms of variant-local slots.
	5	* A variant represents one outgoing contract, while a slot represents one artifact set inside that
	6	* contract.
	7	*
	8	* <p>The model intentionally separates cheap identity objects from stateful build objects:
	9	*
	10	* <ul>
	11	* <li>{@link org.implab.gradle.variants.artifacts.ArtifactSlot} identifies a published slot inside a
	12	* variant;</li>
	13	* <li>{@link org.implab.gradle.variants.artifacts.ArtifactAssembly} is the lazily materialized body of
	14	* that slot.</li>
	15	* </ul>
	16	*
	17	* <p>Each slot is expected to materialize to exactly one published artifact: either one file or one
	18	* directory. Internal build topology such as roles may participate in slot assembly rules, but does not
	19	* belong to external artifact identity.
	20	*
	21	* <p>Typical usage:
	22	*
	23	* <pre>{@code
	24	* variantArtifacts {
	25	* variant("browser") {
	26	* primarySlot("runtime") {
	27	* fromRole("main") { output("js") }
	28	* }
	29	* slot("sources") {
	30	* fromLayer("main") { output("sources") }
	31	* }
	32	* }
	33	* }
	34	* }</pre>
	35	*
	36	* <p>After finalization, slot identities can be observed through
	37	* {@link org.implab.gradle.variants.artifacts.VariantArtifactsContext#getSlots()}, while slot bodies are
	38	* obtained on demand through
	39	* {@link org.implab.gradle.variants.artifacts.VariantArtifactsContext#getAssemblies()}.
	40	*/
	41	package org.implab.gradle.variants.artifacts;

AGENTS.md +2 0

             # AGENTS.md
             ## Проектные договоренности
             ### Публичное 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.**

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

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

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

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

variants/src/test/java/org/implab/gradle/variants/sources/CompileUnitsViewTest.java +3 -3

             package org.implab.gradle.variants.sources;
             import static org.junit.jupiter.api.Assertions.assertEquals;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.lang.reflect.Constructor;
             import java.util.Set;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
             import org.junit.jupiter.api.Test;
             class CompileUnitsViewTest {
                 @Test
                 void deduplicatesCompileUnitsAcrossRolesAndExposesParticipatingRoles() {
                     var browser = new TestVariant("browser");
                     var main = new TestLayer("main");
                     var test = new TestLayer("test");
                     var production = new TestRole("production");
                     var qa = new TestRole("test");
                     var view = view(
                             Set.of(main, test),
                             Set.of(production, qa),
                             Set.of(browser),
                             Set.of(
                                     new VariantRoleLayer(browser, production, main),
                                     new VariantRoleLayer(browser, qa, main),
                                     new VariantRoleLayer(browser, qa, test)));
                     var units = CompileUnitsView.of(view);
-                    var browserMain = units.getUnit(browser, main);
+                    var browserMain = units.requireUnit(browser, main);
-                    var browserTest = units.getUnit(browser, test);
+                    var browserTest = units.requireUnit(browser, test);
                     assertEquals(2, units.getUnits().size());
                     assertEquals(Set.of(browserMain, browserTest), units.getUnitsForVariant(browser));
                     assertEquals(Set.of(production, qa), units.getRoles(browserMain));
                     assertEquals(Set.of(qa), units.getRoles(browserTest));
                     assertTrue(units.contains(browser, main));
                     assertTrue(units.contains(browser, test));
                 }
                 @Test
                 void rejectsMissingCompileUnitLookup() {
                     var browser = new TestVariant("browser");
                     var main = new TestLayer("main");
                     var missing = new TestLayer("missing");
                     var production = new TestRole("production");
                     var view = view(
                             Set.of(main),
                             Set.of(production),
                             Set.of(browser),
                             Set.of(new VariantRoleLayer(browser, production, main)));
                     var units = CompileUnitsView.of(view);
-                    var ex = assertThrows(IllegalArgumentException.class, () -> units.getUnit(browser, missing));
+                    var ex = assertThrows(IllegalArgumentException.class, () -> units.requireUnit(browser, missing));
                     assertTrue(ex.getMessage().contains("Compile unit for variant 'browser' and layer 'missing' not found"));
                 }
                 private static VariantsView view(
                         Set<Layer> layers,
                         Set<Role> roles,
                         Set<Variant> variants,
                         Set<VariantRoleLayer> entries) {
                     try {
                         Constructor<VariantsView> ctor = VariantsView.class.getDeclaredConstructor(
                                 Set.class,
                                 Set.class,
                                 Set.class,
                                 Set.class);
                         ctor.setAccessible(true);
                         return ctor.newInstance(layers, roles, variants, entries);
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to create VariantsView fixture", e);
                     }
                 }
                 private record TestVariant(String value) implements Variant {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestLayer(String value) implements Layer {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestRole(String value) implements Role {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
             }

General Comments 0

Write
Preview

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

No TODOs yet

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

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