implab/gradle-common Commit - r38:87d6128f0bc8

Working on separating variants as standalone plugin

cin -

r38:87d6128f0bc8 default

parent child

Context file:

r38:87d6128f0bc8

Expand all files

common/src/main/java/org/implab/gradle/common/sources/LayerBindingSpec.java created 644 +41 0

@@ -0,0 +1,41
	1	package org.implab.gradle.common.sources;
	2
	3	import org.implab.gradle.common.core.lang.Closures;
	4	import org.gradle.api.Action;
	5	import org.gradle.api.Named;
	6	import org.gradle.api.provider.Property;
	7
	8	import groovy.lang.Closure;
	9	import groovy.lang.DelegatesTo;
	10
	11	/**
	12	* Public DSL contract for per-layer source-set policy and callbacks.
	13	*/
	14	public interface LayerBindingSpec extends Named {
	15	Property<String> getSourceSetNamePattern();
	16
	17	default void setSourceSetNamePattern(String pattern) {
	18	getSourceSetNamePattern().set(pattern);
	19	}
	20
	21	void configureSourceSet(Action<? super GenericSourceSet> configure);
	22
	23	default void configureSourceSet(
	24	@DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
	25	configureSourceSet(Closures.action(configure));
	26	}
	27
	28	void whenRegistered(Action<? super SourceSetRegistration> action);
	29
	30	default void whenRegistered(
	31	@DelegatesTo(value = SourceSetRegistration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	32	whenRegistered(Closures.action(action));
	33	}
	34
	35	void whenBound(Action<? super SourceSetUsageBinding> action);
	36
	37	default void whenBound(
	38	@DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	39	whenBound(Closures.action(action));
	40	}
	41	}

variants/build.gradle created 644 +53 0

@@ -0,0 +1,53
	1	plugins {
	2	id "java-library"
	3	id "ivy-publish"
	4	}
	5
	6	java {
	7	withJavadocJar()
	8	withSourcesJar()
	9	toolchain {
	10	languageVersion = JavaLanguageVersion.of(21)
	11	}
	12	}
	13
	14	dependencies {
	15	compileOnly libs.jdt.annotations
	16
	17	api gradleApi(),
	18	libs.bundles.jackson
	19
	20	implementation project(":common")
	21
	22	testImplementation gradleTestKit()
	23	testImplementation "org.junit.jupiter:junit-jupiter-api:5.11.4"
	24	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.11.4"
	25	testRuntimeOnly "org.junit.platform:junit-platform-launcher:1.11.4"
	26	}
	27
	28	task printVersion{
	29	doLast {
	30	println "project: $project.group:$project.name:$project.version"
	31	println "jar: ${->jar.archiveFileName.get()}"
	32	}
	33	}
	34
	35	test {
	36	useJUnitPlatform()
	37	}
	38
	39	publishing {
	40	repositories {
	41	ivy {
	42	url "${System.properties["user.home"]}/ivy-repo"
	43	}
	44	}
	45	publications {
	46	ivy(IvyPublication) {
	47	from components.java
	48	descriptor.description {
	49	text = providers.provider({ description })
	50	}
	51	}
	52	}
	53	}

variants/src/main/java/org/implab/gradle/variants/VariantsPlugin.java created 644 +17 0

@@ -0,0 +1,17
	1	package org.implab.gradle.variants;
	2
	3	import org.gradle.api.Plugin;
	4	import org.gradle.api.Project;
	5	import org.implab.gradle.variants.model.VariantsExtension;
	6
	7	public abstract class VariantsPlugin implements Plugin<Project> {
	8	@Override
	9	public void apply(Project target) {
	10	var extension = target.getExtensions().create("variants", VariantsExtension.class);
	11
	12	target.afterEvaluate(project -> {
	13
	14	});
	15
	16	}
	17	}

variants/src/main/java/org/implab/gradle/variants/model/Layer.java created 644 +9 0

@@ -0,0 +1,9
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Named;
	4
	5	/**
	6	* Identity-only domain object.
	7	*/
	8	public interface Layer extends Named {
	9	} No newline at end of file

variants/src/main/java/org/implab/gradle/variants/model/Role.java created 644 +9 0

@@ -0,0 +1,9
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Named;
	4
	5	/**
	6	* Identity-only domain object.
	7	*/
	8	public interface Role extends Named {
	9	} No newline at end of file

variants/src/main/java/org/implab/gradle/variants/model/RoleBinding.java created 644 +35 0

@@ -0,0 +1,35
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Named;
	4	import org.gradle.api.provider.SetProperty;
	5
	6	/**
	7	* Binds a role to a set of layers inside a particular variant.
	8	*
	9	* The binding name is the role name, e.g. "production", "test", "tool".
	10	*/
	11	public interface RoleBinding extends Named {
	12
	13	/**
	14	* Layer names participating in this (variant, role) selection.
	15	*
	16	* Core model keeps names here deliberately:
	17	* source/materialization semantics live elsewhere.
	18	*/
	19	SetProperty<String> getLayerNames();
	20
	21	/**
	22	* Adds one layer to this binding.
	23	*/
	24	void layer(String name);
	25
	26	/**
	27	* Adds several layers to this binding.
	28	*/
	29	void layers(String... names);
	30
	31	/**
	32	* Adds several layers to this binding.
	33	*/
	34	void layers(Iterable<String> names);
	35	} No newline at end of file

variants/src/main/java/org/implab/gradle/variants/model/Variant.java created 644 +44 0

@@ -0,0 +1,44
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.Named;
	5	import org.gradle.api.NamedDomainObjectContainer;
	6	import org.implab.gradle.common.core.lang.Closures;
	7
	8	import groovy.lang.Closure;
	9
	10	/**
	11	* A named variant, e.g. "browser", "electron".
	12	*
	13	* A variant does not "have a role" directly.
	14	* It owns a set of role bindings.
	15	*/
	16	public interface Variant extends Named {
	17
	18	/**
	19	* Role bindings declared inside this variant.
	20	*
	21	* The binding name is the role name.
	22	*/
	23	NamedDomainObjectContainer<RoleBinding> getRoleBindings();
	24
	25	/**
	26	* Creates or returns an existing role binding and configures it.
	27	*/
	28	default RoleBinding role(String name) {
	29	return getRoleBindings().maybeCreate(name);
	30	}
	31
	32	/**
	33	* Creates or returns an existing role binding and configures it.
	34	*/
	35	default RoleBinding role(String name, Action<? super RoleBinding> action) {
	36	var role = role(name);
	37	action.execute(role);
	38	return role;
	39	}
	40
	41	default RoleBinding role(String name, Closure<?> closure) {
	42	return role(name, Closures.action(closure));
	43	}
	44	} No newline at end of file

variants/src/main/java/org/implab/gradle/variants/model/VariantsExtension.java created 644 +59 0

@@ -0,0 +1,59
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.NamedDomainObjectContainer;
	5	import org.implab.gradle.common.core.lang.Closures;
	6
	7	import groovy.lang.Closure;
	8
	9	/**
	10	* Root extension:
	11	*
	12	* variants {
	13	* layers { ... }
	14	* roles { ... }
	15	*
	16	* variant("browser") {
	17	* role("production") {
	18	* layers("main", "generated", "mainRjs")
	19	* }
	20	* }
	21	* }
	22	*/
	23	public interface VariantsExtension {
	24
	25	/**
	26	* Domain of layers.
	27	*/
	28	NamedDomainObjectContainer<Layer> getLayers();
	29
	30	/**
	31	* Domain of roles.
	32	*/
	33	NamedDomainObjectContainer<Role> getRoles();
	34
	35	/**
	36	* Declared variants.
	37	*/
	38	NamedDomainObjectContainer<Variant> getVariantDefinitions();
	39
	40	/**
	41	* Creates or returns an existing variant and configures it.
	42	*/
	43	default Variant variant(String name) {
	44	return getVariantDefinitions().maybeCreate(name);
	45	}
	46
	47	/**
	48	* Creates or returns an existing variant and configures it.
	49	*/
	50	default Variant variant(String name, Action<? super Variant> action) {
	51	var variant = variant(name);
	52	action.execute(variant);
	53	return variant;
	54	}
	55
	56	default Variant variant(String name, Closure<?> closure) {
	57	return variant(name, Closures.action(closure));
	58	}
	59	} No newline at end of file

common/readme.md +4 -4

             ## DOMAIN MODEL
-            - `BuildLayer` — глобальный идентификатор слоя.
+            - `BuildLayer` — canonical identity-model объявленного слоя.
             - `BuildVariant` — агрегат ролей, атрибутов, артефактных слотов.
-            - `BuildRole` — роль внутри варианта, содержит ссылки на layer names.
+            - `BuildRole` — роль внутри варианта, содержит ссылки на declared layer names.
             - `GenericSourceSet` — зарегистрированный набор исходников и outputs.
-            - `BuildLayerBinding` — правила registration source set для конкретного layer.
+            - `LayerBindingSpec` — публичный DSL-contract adapter policy/callbacks для слоя.
             - `SourceSetRegistration` — payload события регистрации source set.
             - `SourceSetUsageBinding` — payload события usage-binding.
             - `BuildVariant` — API ролей, attributes и artifact slots варианта.
             - `VariantsSourcesPlugin` — применяет `variants` + `sources` и запускает адаптер.
             - `VariantSourcesExtension` — API bind/events registration.
-            - `BuildLayerBinding` — слой-конкретный DSL для имени и конфигурации source set.
+            - `LayerBindingSpec` — слой-конкретный DSL для policy/configuration source set.
             - `SourceSetRegistration` — payload `whenRegistered(...)`.
             - `SourceSetUsageBinding` — payload `whenBound(...)`.

common/src/main/java/org/implab/gradle/common/sources/BuildVariantsExtension.java +32 -48

             import groovy.lang.Closure;
             public abstract class BuildVariantsExtension {
-                private final NamedDomainObjectContainer<BuildLayer> layers;
+                private final ObjectFactory objects;
+                private final LinkedHashMap<String, LayoutLayer> layersByName = new LinkedHashMap<>();
                 private final NamedDomainObjectContainer<BuildVariant> variants;
                 private final List<Action<? super BuildVariantsExtension>> finalizedActions = new ArrayList<>();
                 private boolean finalized;
                 @Inject
                 public BuildVariantsExtension(ObjectFactory objects) {
-                    layers = objects.domainObjectContainer(BuildLayer.class);
+                    this.objects = objects;
                     variants = objects.domainObjectContainer(BuildVariant.class);
-                    layers.all(layer -> {
-                        if (finalized)
-                            throw new InvalidUserDataException(
-                                    "Variants model is finalized and cannot add layer '" + layer.getName() + "'");
-                    });
                     variants.all(variant -> {
                         if (finalized)
                             throw new InvalidUserDataException(
                     });
                 }
-                public NamedDomainObjectContainer<BuildLayer> getLayers() {
+                public Collection<LayoutLayer> getLayers() {
-                    return layers;
+                    return Collections.unmodifiableCollection(layersByName.values());
                 }
                 public NamedDomainObjectContainer<BuildVariant> getVariants() {
                     return variants;
                 }
-                public void layers(Action<? super NamedDomainObjectContainer<BuildLayer>> action) {
+                public LayoutLayer layer(String name, Action<? super LayoutLayer> configure) {
                     ensureMutable("configure layers");
-                    action.execute(layers);
+                    var layer = layersByName.computeIfAbsent(requireName(name, "Layer name must not be null or blank"), this::newLayer);
-                public void layers(Closure<?> configure) {
-                    layers(Closures.action(configure));
-                public void variants(Action<? super NamedDomainObjectContainer<BuildVariant>> action) {
-                    ensureMutable("configure variants");
-                    action.execute(variants);
-                public void variants(Closure<?> configure) {
-                    variants(Closures.action(configure));
-                public BuildLayer layer(String name, Action<? super BuildLayer> configure) {
-                    ensureMutable("configure layers");
-                    var layer = layers.maybeCreate(name);
                     configure.execute(layer);
                     return layer;
                 }
-                public BuildLayer layer(String name, Closure<?> configure) {
+                public LayoutLayer layer(String name, Closure<?> configure) {
                     return layer(name, Closures.action(configure));
                 }
-                public BuildLayer layer(String name) {
+                public LayoutLayer layer(String name) {
                     return layer(name, it -> {
                     });
                 }
                     return Collections.unmodifiableList(all);
                 }
+                public Optional<LayoutLayer> findLayer(String name) {
+                    var normalizedName = normalize(name);
+                    return normalizedName == null ? Optional.empty() : Optional.ofNullable(layersByName.get(normalizedName));
+                }
+                public LayoutLayer requireLayer(String name) {
+                    return findLayer(name)
+                            .orElseThrow(() -> new InvalidUserDataException("Layer '" + name + "' isn't defined"));
+                }
                 public Optional<BuildVariant> find(String name) {
                     return Optional.ofNullable(variants.findByName(name));
                 }
                 public void validate() {
                     var errors = new ArrayList<String>();
-                    var layersByName = new LinkedHashMap<String, BuildLayer>();
-                    for (var layer : layers) {
-                        var layerName = normalize(layer.getName());
-                        if (layerName == null) {
-                            errors.add("Layer name must not be blank");
-                            continue;
-                        var previous = layersByName.putIfAbsent(layerName, layer);
-                        if (previous != null) {
-                            errors.add("Layer '" + layerName + "' is declared more than once");
                     for (var variant : variants)
                         validateVariant(variant, layersByName, errors);
                     }
                 }
-                private static void validateVariant(BuildVariant variant, Map<String, BuildLayer> layersByName, List<String> errors) {
+                private static void validateVariant(BuildVariant variant, Map<String, LayoutLayer> layersByName, List<String> errors) {
                     var variantName = normalize(variant.getName());
                     if (variantName == null) {
                         errors.add("Variant name must not be blank");
                     }
                 }
-                private static void validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,
+                private static void validateRoleMappings(BuildVariant variant, Map<String, LayoutLayer> layersByName,
                         List<String> errors) {
                     for (var role : variant.getRoles()) {
                         var seenLayers = new LinkedHashSet<String>();
                     return trimmed.isEmpty() ? null : trimmed;
                 }
+                private static String requireName(String value, String errorMessage) {
+                    var normalized = normalize(value);
+                    if (normalized == null)
+                        throw new InvalidUserDataException(errorMessage);
+                    return normalized;
+                }
+                private LayoutLayer newLayer(String name) {
+                    return objects.newInstance(LayoutLayer.class, name);
+                }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("Variants model is finalized and cannot " + operation);

common/src/main/java/org/implab/gradle/common/sources/LayerBinding.java ~~common/src/main/java/org/implab/gradle/common/sources/BuildLayerBinding.java~~ renamed +14 -51

             import java.util.List;
             import java.util.Set;
-            import javax.inject.Inject;
-            import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
-            import org.gradle.api.Named;
             import org.gradle.api.NamedDomainObjectProvider;
+            import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Property;
-            import groovy.lang.Closure;
+            final class LayerBinding implements LayerBindingSpec {
-            import groovy.lang.DelegatesTo;
+                static final String DEFAULT_SOURCE_SET_NAME_PATTERN = "{variant}{layerCap}";
-            /**
-             * Maps a logical layer to per-source-set hooks.
-             */
-            public abstract class BuildLayerBinding implements Named {
-                public static final String DEFAULT_SOURCE_SET_NAME_PATTERN = "{variant}{layerCap}";
                 private final String name;
+                private final Property<String> sourceSetNamePattern;
                 private final List<Action<? super GenericSourceSet>> sourceSetConfigureActions = new ArrayList<>();
                 private final List<Action<? super SourceSetRegistration>> registeredActions = new ArrayList<>();
                 private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();
                 private final Set<String> registeredSourceSetNames = new LinkedHashSet<>();
-                @Inject
+                LayerBinding(String name, ObjectFactory objects) {
-                public BuildLayerBinding(String name) {
                     this.name = name;
-                    getSourceSetNamePattern().convention(DEFAULT_SOURCE_SET_NAME_PATTERN);
+                    sourceSetNamePattern = objects.property(String.class);
+                    sourceSetNamePattern.convention(DEFAULT_SOURCE_SET_NAME_PATTERN);
                 }
                 @Override
                     return name;
                 }
-                public abstract Property<String> getSourceSetNamePattern();
+                @Override
+                public Property<String> getSourceSetNamePattern() {
+                    return sourceSetNamePattern;
+                }
-                /**
+                @Override
-                 * Action applied to every registered source set for this layer.
-                 * Already registered source sets are configured immediately (replay).
-                 */
                 public void configureSourceSet(Action<? super GenericSourceSet> configure) {
                     sourceSetConfigureActions.add(configure);
                     for (var sourceSet : registeredSourceSets)
                         sourceSet.configure(configure);
                 }
-                public void configureSourceSet(
+                @Override
-                        @DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
-                    configureSourceSet(Closures.action(configure));
-                /**
-                 * Layer-local callback fired after source-set registration.
-                 * Already emitted registrations are delivered immediately (replay).
-                 * For simple callbacks you can use delegate-only style
-                 * (for example {@code whenRegistered { sourceSetName() }}).
-                 * For nested closures prefer explicit parameter
-                 * ({@code whenRegistered { ctx -> ... }}).
-                 */
                 public void whenRegistered(Action<? super SourceSetRegistration> action) {
                     registeredActions.add(action);
                     for (var context : registeredContexts)
                         action.execute(context);
                 }
-                public void whenRegistered(
+                @Override
-                        @DelegatesTo(value = SourceSetRegistration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
-                    whenRegistered(Closures.action(action));
-                /**
-                 * Layer-local callback fired for every resolved variant/role/layer usage.
-                 * Already emitted usage bindings are delivered immediately (replay).
-                 * For simple callbacks you can use delegate-only style
-                 * (for example {@code whenBound { variantName() }}).
-                 * For nested closures prefer explicit parameter
-                 * ({@code whenBound { ctx -> ... }}).
-                 */
                 public void whenBound(Action<? super SourceSetUsageBinding> action) {
                     boundActions.add(action);
                     for (var context : boundContexts)
                         action.execute(context);
                 }
-                public void whenBound(
-                        @DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
-                    whenBound(Closures.action(action));
                 void notifyRegistered(SourceSetRegistration registration) {
                     if (registeredSourceSetNames.add(registration.sourceSetName())) {
                         var sourceSet = registration.sourceSet();

common/src/main/java/org/implab/gradle/common/sources/LayoutLayer.java ~~common/src/main/java/org/implab/gradle/common/sources/BuildLayer.java~~ renamed +3 -3

             import org.gradle.api.Named;
             /**
-             * Global layer declaration used by build variants.
+             * Canonical identity model for a declared layout layer.
              */
-            public abstract class BuildLayer implements Named {
+            public abstract class LayoutLayer implements Named {
                 private final String name;
                 @Inject
-                public BuildLayer(String name) {
+                public LayoutLayer(String name) {
                     this.name = name;
                 }

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

              *
              * <p>Used as callback payload for
              * {@link VariantSourcesExtension#whenRegistered(org.gradle.api.Action)} and
-             * {@link BuildLayerBinding#whenRegistered(org.gradle.api.Action)}.
+             * {@link LayerBindingSpec#whenRegistered(org.gradle.api.Action)}.
              *
              * @param layerName normalized layer name that owns the registration
              * @param sourceSetName source-set name registered in the container

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

              *
              * <p>Used as callback payload for
              * {@link VariantSourcesExtension#whenBound(org.gradle.api.Action)} and
-             * {@link BuildLayerBinding#whenBound(org.gradle.api.Action)}.
+             * {@link LayerBindingSpec#whenBound(org.gradle.api.Action)}.
              *
              * @param variantName variant name from the build-variants model
              * @param roleName role name inside the resolved variant

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactSlot.java +4 0

                     return List.copyOf(bindings);
                 }
+                void acceptBindings(Consumer<? super BindingResolver> consumer) {
+                    bindings.forEach(consumer);
+                }
                 Set<String> referencedRoleNames() {
                     return Set.copyOf(referencedRoleNames);
                 }

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsPlugin.java +7 -4

                     var variantArtifactsResolver = new VariantArtifactsResolver(target.getObjects());
                     var artifactAssemblies = new ArtifactAssemblyRegistry(target.getObjects(), target.getTasks());
-                    // Bind variant artifacts resolution to variant sources registration, so that artifact resolution can be performed
+                    // Bind variant artifacts resolution to variant sources registration, so that
+                    // artifact resolution can be performed
                     variantSources.whenBound(variantArtifactsResolver::recordBinding);
                     variants.whenFinalized(model -> {
                     var assemblies = variantArtifact.getSlots().stream()
                             .collect(Collectors.toMap(
                                     VariantArtifactSlot::getName,
-                                    slot -> registerAssembly(project, variantArtifactsResolver, artifactAssemblies, variantArtifact, slot),
+                                    slot -> registerAssembly(project, variantArtifactsResolver, artifactAssemblies, variantArtifact,
+                                            slot),
                                     (left, right) -> left,
                                     LinkedHashMap::new));
                         ArtifactAssemblyRegistry artifactAssemblies,
                         VariantArtifact variantArtifact,
                         VariantArtifactSlot slot) {
+                    String assemblyName = variantArtifact.getName() + Strings.capitalize(slot.getName());
                     return artifactAssemblies.register(
-                            variantArtifact.getName() + Strings.capitalize(slot.getName()),
+                            assemblyName,
-                            "process" + Strings.capitalize(variantArtifact.getName()) + Strings.capitalize(slot.getName()),
+                            "process" + Strings.capitalize(assemblyName),
                             project.getLayout().getBuildDirectory()
                                     .dir("variant-artifacts/" + variantArtifact.getName() + "/" + slot.getName()),
                             files -> files.from(variantArtifactsResolver.files(variantArtifact.getName(), slot)));

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsResolver.java +10 -5

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
+            import java.util.Collection;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Set;
                  * @return lazily wired file collection for the selected outputs
                  */
                 public FileCollection files(String variantName, VariantArtifactSlot slot) {
-                    var builder = new FileCollectionBuilder();
                     var contexts = boundContexts.stream()
                             .filter(context -> variantName.equals(context.variantName()))
                             .toList();
+                    var builder = new FileCollectionBuilder(contexts);
-                    slot.bindings().forEach(binding -> binding.resolve(contexts, builder::addOutput));
+                    slot.acceptBindings(builder::visitBinding);
                     return builder.build();
                 }
                 class FileCollectionBuilder {
                     private final ConfigurableFileCollection files;
                     private final Set<BindingKey> boundOutputs = new LinkedHashSet<>();
+                    private final Collection<SourceSetUsageBinding> contexts;
-                    FileCollectionBuilder() {
+                    FileCollectionBuilder(Collection<SourceSetUsageBinding> contexts) {
                         this.files = objects.fileCollection();
+                        this.contexts = contexts;
                     }
                     FileCollection build() {
                         if (boundOutputs.add(binding.key()))
                             files.from(binding.files());
                     }
+                    void visitBinding(VariantArtifactSlot.BindingResolver resolver) {
+                        resolver.resolve(contexts, this::addOutput);
+                    }
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantSourcesExtension.java +47 -38

             import org.eclipse.jdt.annotation.Nullable;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
-            import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.model.ObjectFactory;
                 private static final Logger logger = Logging.getLogger(VariantSourcesExtension.class);
                 private static final Pattern SOURCE_SET_NAME_TOKEN = Pattern.compile("\\{([A-Za-z][A-Za-z0-9]*)\\}");
+                private final ObjectFactory objects;
                 private final ProjectLayout layout;
-                private final NamedDomainObjectContainer<BuildLayerBinding> bindings;
+                private final LinkedHashMap<String, LayerBinding> bindingsByName = new LinkedHashMap<>();
                 private final List<Action<? super SourceSetRegistration>> registeredActions = new ArrayList<>();
                 private final List<Action<? super SourceSetUsageBinding>> boundActions = new ArrayList<>();
                 private final List<SourceSetRegistration> registeredContexts = new ArrayList<>();
                 @Inject
                 public VariantSourcesExtension(ObjectFactory objects, ProjectLayout layout) {
+                    this.objects = objects;
                     this.layout = layout;
-                    bindings = objects.domainObjectContainer(BuildLayerBinding.class);
                 }
-                public NamedDomainObjectContainer<BuildLayerBinding> getBindings() {
+                public List<LayerBindingSpec> getBindings() {
-                    return bindings;
+                    return bindingsByName.values().stream().map(x -> (LayerBindingSpec)x).toList();
                 }
-                public void bindings(Action<? super NamedDomainObjectContainer<BuildLayerBinding>> action) {
+                public LayerBindingSpec bind(String layer) {
-                    action.execute(bindings);
+                    return bindingsByName.computeIfAbsent(
+                            normalize(layer, "Layer name must not be null or blank"),
+                            name -> new LayerBinding(name, objects));
                 }
-                public void bindings(
+                public LayerBindingSpec bind(LayoutLayer layer) {
-                        @DelegatesTo(value = NamedDomainObjectContainer.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
+                    return bind(layer.getName());
-                    bindings(Closures.action(action));
-                public BuildLayerBinding bind(String layer) {
-                    return bindings.maybeCreate(normalize(layer, "Layer name must not be null or blank"));
                 }
                 /**
                  * Configures per-layer binding.
                  */
-                public BuildLayerBinding bind(String layer, Action<? super BuildLayerBinding> configure) {
+                public LayerBindingSpec bind(String layer, Action<? super LayerBindingSpec> configure) {
                     var binding = bind(layer);
                     configure.execute(binding);
                     return binding;
                 }
-                public BuildLayerBinding bind(String layer,
+                public LayerBindingSpec bind(LayoutLayer layer, Action<? super LayerBindingSpec> configure) {
-                        @DelegatesTo(value = BuildLayerBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
+                    var binding = bind(layer);
+                    configure.execute(binding);
+                    return binding;
+                }
+                public LayerBindingSpec bind(String layer,
+                        @DelegatesTo(value = LayerBindingSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
+                    return bind(layer, Closures.action(configure));
+                }
+                public LayerBindingSpec bind(LayoutLayer layer,
+                        @DelegatesTo(value = LayerBindingSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return bind(layer, Closures.action(configure));
                 }
                     whenBound(variantName, Closures.action(action));
                 }
-                void registerSourceSets(BuildVariantsExtension variants, NamedDomainObjectContainer<GenericSourceSet> sources) {
+                void registerSourceSets(BuildVariantsExtension variants, org.gradle.api.NamedDomainObjectContainer<GenericSourceSet> sources) {
                     if (sourceSetsRegistered) {
                         throw new InvalidUserDataException("variantSources source sets are already registered");
                     }
-                    validateBindings(variants);
+                    resolveBindings(variants);
                     var usages = layerUsages(variants).toList();
                     var registeredBefore = registeredContexts.size();
                             "Starting variant source-set registration (variants={}, layers={}, bindings={}, usages={})",
                             variants.getVariants().size(),
                             variants.getLayers().size(),
-                            bindings.size(),
+                            bindingsByName.size(),
                             usages.size());
                     usages.forEach(usage -> registerLayerUsage(usage, sources));
                                             .map(layerName -> new LayerUsage(
                                                     variant.getName(),
                                                     role.getName(),
-                                                    normalize(layerName, "Layer name in variant '" + variant.getName()
+                                                    variants.requireLayer(normalize(layerName, "Layer name in variant '"
-                                                            + "' and role '" + role.getName() + "' must not be null or blank")))));
+                                                            + variant.getName() + "' and role '" + role.getName()
+                                                            + "' must not be null or blank"))))));
                 }
-                private void registerLayerUsage(LayerUsage usage, NamedDomainObjectContainer<GenericSourceSet> sources) {
+                private void registerLayerUsage(LayerUsage usage, org.gradle.api.NamedDomainObjectContainer<GenericSourceSet> sources) {
-                    var resolvedBinding = bind(usage.layerName());
+                    var resolvedBinding = binding(usage.layer().getName());
                     var sourceSetNamePattern = resolvedBinding.getSourceSetNamePattern();
                     sourceSetNamePattern.finalizeValueOnRead();
                     var sourceSetName = sourceSetName(usage, sourceSetNamePattern.get());
-                    ensureSourceSetNameBoundToSingleLayer(sourceSetName, usage.layerName());
+                    ensureSourceSetNameBoundToSingleLayer(sourceSetName, usage.layer().getName());
                     var isNewSourceSet = !sourceSetsByName.containsKey(sourceSetName);
                     var sourceSet = sourceSetsByName.computeIfAbsent(sourceSetName,
                             name -> {
                                 var ssp = sources.register(name);
                                 ssp.configure(x -> {
-                                    x.getSourceSetDir().set(layout.getProjectDirectory().dir("src/" + usage.layerName()));
+                                    x.getSourceSetDir().set(layout.getProjectDirectory().dir("src/" + usage.layer().getName()));
                                 });
                                 return ssp;
                             });
                     var binding = new SourceSetUsageBinding(
                             usage.variantName(),
                             usage.roleName(),
-                            usage.layerName(),
+                            usage.layer().getName(),
                             sourceSetName,
                             sourceSet);
                     if (isNewSourceSet) {
                         var registration = new SourceSetRegistration(
-                                usage.layerName(),
+                                usage.layer().getName(),
                                 sourceSetName,
                                 sourceSet);
                         resolvedBinding.notifyRegistered(registration);
                     }
                 }
-                private void validateBindings(BuildVariantsExtension variants) {
+                private void resolveBindings(BuildVariantsExtension variants) {
-                    var knownLayerNames = new java.util.LinkedHashSet<String>();
-                    for (var layer : variants.getLayers())
-                        knownLayerNames.add(layer.getName());
                     var errors = new ArrayList<String>();
-                    for (var binding : bindings) {
+                    for (var binding : bindingsByName.values()) {
-                        if (!knownLayerNames.contains(binding.getName())) {
+                        if (variants.findLayer(binding.getName()).isEmpty()) {
                             errors.add("Layer binding '" + binding.getName() + "' references unknown layer");
                         }
                     }
                     }
                 }
+                private LayerBinding binding(String layerName) {
+                    return bindingsByName.computeIfAbsent(layerName, name -> new LayerBinding(name, objects));
+                }
                 private static String sourceSetName(LayerUsage usage, String pattern) {
                     var normalizedPattern = normalize(pattern, "sourceSetNamePattern must not be null or blank");
                     var resolved = resolveSourceSetNamePattern(normalizedPattern, usage);
                         case "variantCap" -> Strings.capitalize(sanitizeName(usage.variantName()));
                         case "role" -> sanitizeName(usage.roleName());
                         case "roleCap" -> Strings.capitalize(sanitizeName(usage.roleName()));
-                        case "layer" -> sanitizeName(usage.layerName());
+                        case "layer" -> sanitizeName(usage.layer().getName());
-                        case "layerCap" -> Strings.capitalize(sanitizeName(usage.layerName()));
+                        case "layerCap" -> Strings.capitalize(sanitizeName(usage.layer().getName()));
                         default -> throw new InvalidUserDataException(
                                 "sourceSetNamePattern contains unsupported token '{" + token + "}'");
                     };
                     return trimmed;
                 }
-                private record LayerUsage(String variantName, String roleName, String layerName) {
+                private record LayerUsage(String variantName, String roleName, LayoutLayer layer) {
                 }
             }

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

                         }
                         variants {
-                            layer('mainBase')
+                            layers('mainBase', 'mainAmd')
-                            layer('mainAmd')
+                            roles('main', 'test')
                             variant('browser') {
                                 role('main') {

common/src/test/java/org/implab/gradle/common/sources/VariantsPluginFunctionalTest.java +35 0

@@ -64,6 +64,41 class VariantsPluginFunctionalTest {
64	}	64	}
65		65
66	@Test	66	@Test
		67	void supportsLayerRegistryDslAndLookupApi() throws Exception {
		68	writeFile(SETTINGS_FILE, ROOT_NAME);
		69	writeFile(BUILD_FILE, """
		70	plugins {
		71	id 'org.implab.gradle-variants'
		72	}
		73
		74	variants {
		75	layer('mainBase')
		76	layer('mainAmd')
		77
		78	variant('browser') {
		79	role('main') {
		80	layers('mainBase', 'mainAmd')
		81	}
		82	}
		83	}
		84
		85	tasks.register('probe') {
		86	doLast {
		87	println('layers=' + variants.layers.collect { it.name }.sort().join(','))
		88	println('requireLayer=' + variants.requireLayer('mainBase').name)
		89	println('findLayer=' + variants.findLayer('missing').isPresent())
		90	}
		91	}
		92	""");
		93
		94	BuildResult result = runner("probe").build();
		95
		96	assertTrue(result.getOutput().contains("layers=mainAmd,mainBase"));
		97	assertTrue(result.getOutput().contains("requireLayer=mainBase"));
		98	assertTrue(result.getOutput().contains("findLayer=false"));
		99	}
		100
		101	@Test
67	void failsOnUnknownLayerReference() throws Exception {	102	void failsOnUnknownLayerReference() throws Exception {
68	assertBuildFails("""	103	assertBuildFails("""
69	plugins {	104	plugins {

common/src/test/java/org/implab/gradle/common/sources/VariantsSourcesPluginFunctionalTest.java +77 0

@@ -133,6 +133,83 class VariantsSourcesPluginFunctionalTes
133	}	133	}
134		134
135	@Test	135	@Test
		136	void supportsBindingByBuildLayerIdentity() throws Exception {
		137	writeFile(SETTINGS_FILE, ROOT_NAME);
		138	writeFile(BUILD_FILE, """
		139	plugins {
		140	id 'org.implab.gradle-variants-sources'
		141	}
		142
		143	variants {
		144	layer('main')
		145	variant('browser') {
		146	role('main') { layers('main') }
		147	}
		148	}
		149
		150	variantSources {
		151	bind(variants.requireLayer('main')) {
		152	configureSourceSet {
		153	declareOutputs('compiled')
		154	}
		155	}
		156	}
		157
		158	tasks.register('probe') {
		159	doLast {
		160	def ss = sources.getByName('browserMain')
		161	ss.output('compiled')
		162	println('bindLayerIdentity=ok')
		163	}
		164	}
		165	""");
		166
		167	BuildResult result = runner("probe").build();
		168	assertTrue(result.getOutput().contains("bindLayerIdentity=ok"));
		169	}
		170
		171	@Test
		172	void exposesBindingsSnapshot() throws Exception {
		173	writeFile(SETTINGS_FILE, ROOT_NAME);
		174	writeFile(BUILD_FILE, """
		175	plugins {
		176	id 'org.implab.gradle-variants-sources'
		177	}
		178
		179	variants {
		180	layer('main')
		181	layer('extra')
		182	variant('browser') {
		183	role('main') { layers('main') }
		184	}
		185	}
		186
		187	variantSources {
		188	bind('main') {
		189	sourceSetNamePattern = '{layer}'
		190	configureSourceSet {
		191	declareOutputs('compiled')
		192	}
		193	}
		194	bind('extra')
		195	}
		196
		197	tasks.register('probe') {
		198	doLast {
		199	def ss = sources.getByName('main')
		200	ss.output('compiled')
		201	println("bindings=" + variantSources.bindings.collect { it.name }.sort().join(','))
		202	println('bindingsSnapshot=ok')
		203	}
		204	}
		205	""");
		206
		207	BuildResult result = runner("probe").build();
		208	assertTrue(result.getOutput().contains("bindings=extra,main"));
		209	assertTrue(result.getOutput().contains("bindingsSnapshot=ok"));
		210	}
		211
		212	@Test
136	void failsOnUnknownLayerBinding() throws Exception {	213	void failsOnUnknownLayerBinding() throws Exception {
137	writeFile(SETTINGS_FILE, ROOT_NAME);	214	writeFile(SETTINGS_FILE, ROOT_NAME);
138	writeFile(BUILD_FILE, """	215	writeFile(BUILD_FILE, """

common/variant-sources-plugin.md +8 -4

             ### binding
-            `bind('<layer>')` возвращает `BuildLayerBinding` и задает policy для этого
+            `bind('<layer>')` возвращает `LayerBindingSpec` и задает policy для этого
             слоя:
             - как именовать source set;
             ### VariantSourcesExtension
+            - `bind(BuildLayer)` — получить/создать binding для canonical layer identity.
             - `bind(String)` — получить/создать binding по имени слоя.
             - `bind(String, Action|Closure)` — сконфигурировать binding.
-            - `bindings(Action|Closure)` — контейнерная конфигурация bindings.
+            - `bind(BuildLayer, Action|Closure)` — сконфигурировать binding по `BuildLayer`.
+            - `getBindings()` — read-only snapshot текущих bindings.
             - `whenRegistered(...)` — глобальные callbacks регистрации source set.
             - `whenBound(...)` — глобальные callbacks usage-binding.
             - `whenBound(String variantName, ...)` — usage-binding callbacks с variant-filter.
-            ### BuildLayerBinding
+            ### LayerBindingSpec
             - `sourceSetNamePattern` — naming policy для source set слоя.
             - `configureSourceSet(...)` — слойная конфигурация `GenericSourceSet`.
             - `VariantsSourcesPlugin` — точка входа plugin adapter.
             - `VariantSourcesExtension` — глобальный DSL bind/events.
-            - `BuildLayerBinding` — layer-local policy и callbacks.
+            - `LayerBindingSpec` — публичный DSL-contract layer-local policy/callbacks.
             - `SourceSetRegistration` — payload регистрации source set.
             - `SourceSetUsageBinding` — payload usage-binding.
             - `sourceSetNamePattern` фиксируется при первом чтении в registration
               (`finalizeValueOnRead`).
+            - runtime state bindings скрыт внутри adapter implementation (`LayerBinding`).
+            - name-based bindings резолвятся к canonical `BuildLayer` через registry `variants`.
             - Closure callbacks используют delegate-first.
             - Для вложенных closure лучше явный параметр (`ctx -> ...`).

common/variants-plugin.md +4 -2

             - `layer(...)` — объявление или конфигурация `BuildLayer`.
             - `variant(...)` — объявление или конфигурация `BuildVariant`.
-            - `layers { ... }`, `variants { ... }` — контейнерный DSL.
+            - `layers { layer(...) }`, `variants { ... }` — grouped DSL без публикации container API наружу.
             - `all(...)` — callback для всех вариантов.
+            - `findLayer(name)`, `requireLayer(name)`, `getAllLayers()` — доступ к registry слоев.
             - `getAll()`, `find(name)`, `require(name)` — доступ к вариантам.
             - `validate()` — явный запуск валидации.
             - `finalizeModel()` — валидация + финализация модели.
             - `VariantsPlugin` — точка входа плагина.
             - `BuildVariantsExtension` — root extension и lifecycle.
             - `BuildVariant` — агрегатная модель варианта.
-            - `BuildLayer` — модель слоя.
+            - `BuildLayer` — canonical identity-model слоя.
             - `BuildRole` — модель роли.
             - `BuildArtifactSlot` — модель артефактного слота.
             - `VariantAttributes` — typed wrapper для variant attributes.
             ## NOTES
             - Модель `variants` intentionally agnostic к toolchain.
+            - Layer registry хранится как явная identity-map, а не как публичный `NamedDomainObjectContainer`.
             - Интеграция с задачами выполняется через `variantSources` и адаптеры.

settings.gradle +1 0

             rootProject.name = 'gradle-common'
             include 'common'
+            include 'variants'

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