implab/gradle-common Commit - r31:414a5d71eaa5

separated SourceSetRegistration, SourceSetUsageBinding

cin -

r31:414a5d71eaa5 default

parent child

Context file:

r31:414a5d71eaa5

Collapse all files

common/src/main/java/org/implab/gradle/common/sources/SourceSetRegistration.java created 644 +33 0

@@ -0,0 +1,33
	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.NamedDomainObjectProvider;
	6
	7	import groovy.lang.Closure;
	8	import groovy.lang.DelegatesTo;
	9
	10	/**
	11	* Immutable payload for a newly registered {@link GenericSourceSet}.
	12	*
	13	* <p>Used as callback payload for
	14	* {@link VariantSourcesExtension#whenRegistered(org.gradle.api.Action)} and
	15	* {@link BuildLayerBinding#whenRegistered(org.gradle.api.Action)}.
	16	*
	17	* @param layerName normalized layer name that owns the registration
	18	* @param sourceSetName source-set name registered in the container
	19	* @param sourceSet provider of the registered source set (realized later by Gradle on demand)
	20	*/
	21	public record SourceSetRegistration(
	22	String layerName,
	23	String sourceSetName,
	24	NamedDomainObjectProvider<GenericSourceSet> sourceSet) {
	25	public void configureSourceSet(Action<? super GenericSourceSet> action) {
	26	sourceSet.configure(action);
	27	}
	28
	29	public void configureSourceSet(
	30	@DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	31	configureSourceSet(Closures.action(action));
	32	}
	33	}

common/src/main/java/org/implab/gradle/common/sources/SourceSetUsageBinding.java created 644 +37 0

@@ -0,0 +1,37
	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.NamedDomainObjectProvider;
	6
	7	import groovy.lang.Closure;
	8	import groovy.lang.DelegatesTo;
	9
	10	/**
	11	* Immutable payload for a resolved variant/role/layer usage bound to a source set.
	12	*
	13	* <p>Used as callback payload for
	14	* {@link VariantSourcesExtension#whenBound(org.gradle.api.Action)} and
	15	* {@link BuildLayerBinding#whenBound(org.gradle.api.Action)}.
	16	*
	17	* @param variantName variant name from the build-variants model
	18	* @param roleName role name inside the resolved variant
	19	* @param layerName normalized layer name used to resolve the source set
	20	* @param sourceSetName source-set name registered in the container
	21	* @param sourceSet provider of the registered source set (realized later by Gradle on demand)
	22	*/
	23	public record SourceSetUsageBinding(
	24	String variantName,
	25	String roleName,
	26	String layerName,
	27	String sourceSetName,
	28	NamedDomainObjectProvider<GenericSourceSet> sourceSet) {
	29	public void configureSourceSet(Action<? super GenericSourceSet> action) {
	30	sourceSet.configure(action);
	31	}
	32
	33	public void configureSourceSet(
	34	@DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	35	configureSourceSet(Closures.action(action));
	36	}
	37	}

common/readme.md +4 -2

             # Gradle Common Sources Model
             ## NAME
             `gradle-common/common` — набор плагинов для моделирования вариантов сборки,
             регистрации source sets и интеграции этой модели с toolchain-адаптерами.
             ## SYNOPSIS
             ```groovy
             plugins {
                 id 'org.implab.gradle-variants-sources'
             }
             variants {
                 layer('mainBase')
                 layer('mainAmd')
                 variant('browser') {
                     role('main') { layers('mainBase', 'mainAmd') }
                 }
             }
             variantSources {
                 bind('mainBase') {
                     configureSourceSet {
                         declareOutputs('compiled')
                     }
                 }
                 bind('mainAmd').sourceSetNamePattern = '{variant}{layerCap}'
                 whenRegistered { sourceSetName() }
                 whenBound { ctx ->
                     ctx.configureSourceSet {
                         declareOutputs('typings')
                     }
                 }
             }
             ```
             ## DESCRIPTION
             Модуль состоит из трех логических частей:
             - `variants` — декларативная доменная модель сборки;
             - `sources` — модель физически регистрируемых source sets;
             - `variantSources` — адаптер, который связывает первые две модели.
             Ниже раскрытие каждой части.
             ### variants
             `variants` задает структуру пространства сборки: какие есть слои, какие роли
             используют эти слои в каждом варианте, какие есть атрибуты и artifact slots.
             Модель не создает задачи и не привязана к TS/JS.
             Практический смысл:
             - формализовать архитектуру сборки;
             - дать адаптерам единый источник правды.
             ### sources
             `sources` описывает независимые source sets (`GenericSourceSet`) с именованными
             outputs. Это уже "физический" уровень, к которому удобно привязывать задачи,
             артефакты и task inputs/outputs.
             Практический смысл:
             - создать единый контракт по входам/выходам;
             - регистрировать результаты задач как outputs source set;
             - минимизировать ручные `dependsOn` за счет модели outputs.
             ### variantSources
             `variantSources` регистрирует source sets на основе `variants`, применяет
             конфигурацию layer-bindings и отдает события (`whenRegistered`, `whenBound`) для
             адаптеров других плагинов.
             Практический смысл:
             - переводить логическую модель `variants` в executable-модель `sources`;
             - навешивать политики toolchain на зарегистрированные source sets;
             - синхронизировать плагины через replayable callback-контракт.
             ## DOMAIN MODEL
             - `BuildLayer` — глобальный идентификатор слоя.
             - `BuildVariant` — агрегат ролей, атрибутов, артефактных слотов.
             - `BuildRole` — роль внутри варианта, содержит ссылки на layer names.
             - `GenericSourceSet` — зарегистрированный набор исходников и outputs.
             - `BuildLayerBinding` — правила registration source set для конкретного layer.
-            - `SourceSetContext` — контекст callback-событий registration.
+            - `SourceSetRegistration` — payload события регистрации source set.
+            - `SourceSetUsageBinding` — payload события usage-binding.
             ## EVENT CONTRACT
             - `whenRegistered`:
               - событие нового уникального source set name;
               - replayable.
             - `whenBound`:
               - событие каждой usage-связки `variant/role/layer`;
               - replayable.
             Closure callbacks работают в delegate-first режиме (`@DelegatesTo`). Для
             вложенных closure рекомендуется явный параметр (`ctx -> ...`).
             ## KEY CLASSES
             - `SourcesPlugin` — регистрирует extension `sources`.
             - `GenericSourceSet` — модель источников/outputs для конкретного имени.
             - `VariantsPlugin` — регистрирует extension `variants` и lifecycle finalize.
             - `BuildVariantsExtension` — корневой API модели вариантов.
             - `BuildVariant` — API ролей, attributes и artifact slots варианта.
             - `VariantsSourcesPlugin` — применяет `variants` + `sources` и запускает адаптер.
             - `VariantSourcesExtension` — API bind/events registration.
             - `BuildLayerBinding` — слой-конкретный DSL для имени и конфигурации source set.
-            - `SourceSetContext` — payload событий и sugar `configureSourceSet(...)`.
+            - `SourceSetRegistration` — payload `whenRegistered(...)`.
+            - `SourceSetUsageBinding` — payload `whenBound(...)`.
             ## NOTES
             - Marker ids:
               - `org.implab.gradle-variants`
               - `org.implab.gradle-variants-sources`
             - `SourcesPlugin` пока class-only (без marker id).
             ## SEE ALSO
             - `sources-plugin.md`
             - `variants-plugin.md`
             - `variant-sources-plugin.md`

common/src/main/java/org/implab/gradle/common/sources/BuildLayerBinding.java +18 -18

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.LinkedHashSet;
             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.provider.Property;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             /**
              * 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 List<Action<? super GenericSourceSet>> sourceSetConfigureActions = new ArrayList<>();
-                private final List<Action<? super SourceSetContext>> registeredActions = new ArrayList<>();
+                private final List<Action<? super SourceSetRegistration>> registeredActions = new ArrayList<>();
-                private final List<Action<? super SourceSetContext>> boundActions = new ArrayList<>();
+                private final List<Action<? super SourceSetUsageBinding>> boundActions = new ArrayList<>();
                 private final List<NamedDomainObjectProvider<GenericSourceSet>> registeredSourceSets = new ArrayList<>();
-                private final List<SourceSetContext> registeredContexts = new ArrayList<>();
+                private final List<SourceSetRegistration> registeredContexts = new ArrayList<>();
-                private final List<SourceSetContext> boundContexts = new ArrayList<>();
+                private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();
                 private final Set<String> registeredSourceSetNames = new LinkedHashSet<>();
                 @Inject
                 public BuildLayerBinding(String name) {
                     this.name = name;
                     getSourceSetNamePattern().convention(DEFAULT_SOURCE_SET_NAME_PATTERN);
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 public abstract Property<String> getSourceSetNamePattern();
                 /**
                  * 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(
                         @DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     configureSourceSet(Closures.action(configure));
                 }
                 /**
                  * Layer-local callback fired after source-set registration.
-                 * Already emitted contexts are delivered immediately (replay).
+                 * 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 SourceSetContext> action) {
+                public void whenRegistered(Action<? super SourceSetRegistration> action) {
                     registeredActions.add(action);
                     for (var context : registeredContexts)
                         action.execute(context);
                 }
                 public void whenRegistered(
-                        @DelegatesTo(value = SourceSetContext.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
+                        @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 contexts are delivered immediately (replay).
+                 * 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 SourceSetContext> action) {
+                public void whenBound(Action<? super SourceSetUsageBinding> action) {
                     boundActions.add(action);
                     for (var context : boundContexts)
                         action.execute(context);
                 }
                 public void whenBound(
-                        @DelegatesTo(value = SourceSetContext.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
+                        @DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenBound(Closures.action(action));
                 }
-                void notifyRegistered(SourceSetContext context) {
+                void notifyRegistered(SourceSetRegistration registration) {
-                    if (registeredSourceSetNames.add(context.sourceSetName())) {
+                    if (registeredSourceSetNames.add(registration.sourceSetName())) {
-                        var sourceSet = context.sourceSet();
+                        var sourceSet = registration.sourceSet();
                         registeredSourceSets.add(sourceSet);
                         for (var action : sourceSetConfigureActions)
                             sourceSet.configure(action);
                     }
-                    registeredContexts.add(context);
+                    registeredContexts.add(registration);
                     for (var action : registeredActions)
-                        action.execute(context);
+                        action.execute(registration);
                 }
-                void notifyBound(SourceSetContext context) {
+                void notifyBound(SourceSetUsageBinding binding) {
-                    boundContexts.add(context);
+                    boundContexts.add(binding);
                     for (var action : boundActions)
-                        action.execute(context);
+                        action.execute(binding);
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantSourcesExtension.java +33 -39

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

common/src/test/java/org/implab/gradle/common/sources/VariantsSourcesPluginFunctionalTest.java +16 -15

             package org.implab.gradle.common.sources;
             import static org.junit.jupiter.api.Assertions.assertNotNull;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.io.File;
             import java.io.IOException;
             import java.nio.file.Files;
             import java.nio.file.Path;
             import java.util.List;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.GradleRunner;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.gradle.testkit.runner.UnexpectedBuildFailure;
             import org.junit.jupiter.api.Test;
             import org.junit.jupiter.api.io.TempDir;
             class VariantsSourcesPluginFunctionalTest {
                 private static final String SETTINGS_FILE = "settings.gradle";
                 private static final String BUILD_FILE = "build.gradle";
                 private static final String ROOT_NAME = "rootProject.name = 'variants-sources-fixture'\n";
                 @TempDir
                 Path testProjectDir;
                 @Test
                 void registersVariantSourceSetsAndFiresCallbacks() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('mainBase')
                                 layer('mainAmd')
                                 variant('browser') {
                                     role('main') { layers('mainBase', 'mainAmd') }
                                 }
                                 variant('node') {
                                     role('main') { layers('mainBase') }
                                 }
                             }
                             def events = []
                             def localEvents = []
                             variantSources {
                                 bind('mainBase') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                                 bind('mainAmd') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                                 bind('mainAmd').whenRegistered { ctx ->
-                                    localEvents << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
+                                    localEvents << "${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                                 whenRegistered { ctx ->
-                                    events << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
+                                    events << "${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     println("sources=" + sources.collect { it.name }.sort().join(','))
                                     println("events=" + events.sort().join('|'))
                                     println("local=" + localEvents.sort().join('|'))
                                     def base = sources.getByName('browserMainBase')
                                     def amd = sources.getByName('browserMainAmd')
                                     def nodeBase = sources.getByName('nodeMainBase')
                                     base.output('compiled')
                                     amd.output('compiled')
                                     nodeBase.output('compiled')
                                     println('outputs=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("sources=browserMainAmd,browserMainBase,nodeMainBase"));
-                    assertTrue(result.getOutput().contains(
+                    assertTrue(result.getOutput().contains("events=mainAmd:browserMainAmd|mainBase:browserMainBase|mainBase:nodeMainBase"));
-                            "events=browser:main:mainAmd:browserMainAmd|browser:main:mainBase:browserMainBase|node:main:mainBase:nodeMainBase"));
+                    assertTrue(result.getOutput().contains("local=mainAmd:browserMainAmd"));
-                    assertTrue(result.getOutput().contains("local=browser:main:mainAmd:browserMainAmd"));
                     assertTrue(result.getOutput().contains("outputs=ok"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void supportsTrailingClosureOnBind() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                             }
                             variantSources {
                                 bind('main') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def ss = sources.getByName('browserMain')
                                     ss.output('compiled')
                                     println('bindClosure=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("bindClosure=ok"));
                 }
                 @Test
                 void failsOnUnknownLayerBinding() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                             }
                             variantSources {
                                 bind('missing')
                             }
                             """);
                     var ex = assertThrows(UnexpectedBuildFailure.class, () -> runner("help").build());
                     assertTrue(ex.getBuildResult().getOutput().contains("Layer binding 'missing' references unknown layer"));
                 }
                 @Test
-                void exposesProviderInSourceSetRegisteredContext() throws Exception {
+                void exposesProviderInSourceSetRegistration() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                             }
                             variantSources {
                                 whenRegistered {
                                     configureSourceSet {
                                         declareOutputs('generated')
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def ss = sources.getByName('browserMain')
                                     ss.output('generated')
                                     println('contextProvider=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("contextProvider=ok"));
                 }
                 @Test
                 void replaysLateBindingsAndCallbacksAfterRegistration() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                             }
                             def events = []
                             afterEvaluate {
                                 variantSources {
                                     bind('main') {
                                         configureSourceSet {
                                             declareOutputs('late')
                                         }
                                     }
                                     bind('main').whenRegistered { ctx ->
                                         events << "layer:${ctx.sourceSetName()}"
                                     }
                                     whenRegistered { ctx ->
                                         events << "global:${ctx.sourceSetName()}"
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def ss = sources.getByName('browserMain')
                                     ss.output('late')
                                     println("events=" + events.sort().join('|'))
                                     println('lateReplay=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("events=global:browserMain|layer:browserMain"));
                     assertTrue(result.getOutput().contains("lateReplay=ok"));
                 }
                 @Test
                 void supportsSourceSetNamePatternAndSharedRegistration() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                                 variant('node') {
                                     role('main') { layers('main') }
                                 }
                             }
                             def registeredEvents = []
-                            def browserRegisteredEvents = []
                             def boundEvents = []
                             def browserBoundEvents = []
+                            def localRegisteredEvents = []
                             def localBoundEvents = []
                             variantSources {
                                 bind('main').sourceSetNamePattern = '{layer}'
                                 bind('main') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                                 bind('main') {
+                                    whenRegistered {
+                                        localRegisteredEvents << "${layerName()}:${sourceSetName()}"
+                                    }
+                                }
+                                bind('main') {
                                     whenBound {
                                         localBoundEvents << "${variantName()}:${roleName()}:${layerName()}:${sourceSetName()}"
                                     }
                                 }
                                 whenRegistered { ctx ->
-                                    registeredEvents << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
+                                    registeredEvents << "${ctx.layerName()}:${ctx.sourceSetName()}"
-                                whenRegistered('browser') { ctx ->
-                                    browserRegisteredEvents << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                                 whenBound { ctx ->
                                     boundEvents << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                                 whenBound('browser') { ctx ->
                                     browserBoundEvents << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     println("sources=" + sources.collect { it.name }.sort().join(','))
                                     def main = sources.getByName('main')
                                     main.output('compiled')
                                     println("registered=" + registeredEvents.sort().join('|'))
-                                    println("browserRegistered=" + browserRegisteredEvents.sort().join('|'))
+                                    println("localRegistered=" + localRegisteredEvents.sort().join('|'))
                                     println("bound=" + boundEvents.sort().join('|'))
                                     println("browserBound=" + browserBoundEvents.sort().join('|'))
                                     println("localBound=" + localBoundEvents.sort().join('|'))
                                     println('sharedPattern=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("sources=main"));
-                    assertTrue(result.getOutput().contains("registered=browser:main:main:main"));
+                    assertTrue(result.getOutput().contains("registered=main:main"));
-                    assertTrue(result.getOutput().contains("browserRegistered=browser:main:main:main"));
+                    assertTrue(result.getOutput().contains("localRegistered=main:main"));
                     assertTrue(result.getOutput().contains("bound=browser:main:main:main|node:main:main:main"));
                     assertTrue(result.getOutput().contains("browserBound=browser:main:main:main"));
                     assertTrue(result.getOutput().contains("localBound=browser:main:main:main|node:main:main:main"));
                     assertTrue(result.getOutput().contains("sharedPattern=ok"));
                 }
                 private GradleRunner runner(String... arguments) {
                     return GradleRunner.create()
                             .withProjectDir(testProjectDir.toFile())
                             .withPluginClasspath(pluginClasspath())
                             .withArguments(arguments)
                             .forwardOutput();
                 }
                 private static List<File> pluginClasspath() {
                     try {
                         var classesDir = Path.of(VariantsSourcesPlugin.class
                                 .getProtectionDomain()
                                 .getCodeSource()
                                 .getLocation()
                                 .toURI());
                         var markerResource = VariantsSourcesPlugin.class.getClassLoader()
                                 .getResource("META-INF/gradle-plugins/org.implab.gradle-variants-sources.properties");
                         assertNotNull(markerResource, "Plugin marker resource is missing from test classpath");
                         var markerPath = Path.of(markerResource.toURI());
                         var resourcesDir = markerPath.getParent().getParent().getParent();
                         return List.of(classesDir.toFile(), resourcesDir.toFile());
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to build plugin classpath for test", e);
                     }
                 }
                 private void writeFile(String relativePath, String content) throws IOException {
                     Path path = testProjectDir.resolve(relativePath);
                     Files.createDirectories(path.getParent());
                     Files.writeString(path, content);
                 }
             }

common/variant-sources-plugin.md +15 -5

             # Variant Sources Plugin
             ## NAME
             `VariantsSourcesPlugin` и extension `variantSources`.
             ## SYNOPSIS
             ```groovy
             plugins {
                 id 'org.implab.gradle-variants-sources'
             }
             variants {
                 layer('main')
                 variant('browser') {
                     role('main') { layers('main') }
                 }
                 variant('node') {
                     role('main') { layers('main') }
                 }
             }
             variantSources {
                 bind('main').sourceSetNamePattern = '{layer}'
                 bind('main') {
                     configureSourceSet {
                         declareOutputs('compiled')
                     }
                 }
                 whenRegistered { sourceSetName() }
                 whenBound('browser') { roleName() }
             }
             ```
             ## DESCRIPTION
             `VariantsSourcesPlugin` применяет `VariantsPlugin` и `SourcesPlugin`, затем
             регистрирует source sets из модели `variants`.
             Точка запуска registration:
             - `variants.whenFinalized(model -> registerSourceSets(...))`
             ### registration
             Для каждой usage-связки `variant/role/layer` вычисляется имя source set,
             регистрируется `GenericSourceSet` (если он еще не существует), затем
             вызываются callbacks.
             ### binding
             `bind('<layer>')` возвращает `BuildLayerBinding` и задает policy для этого
             слоя:
             - как именовать source set;
             - как конфигурировать source set;
             - какие callbacks вызвать на registration/binding.
             ### sourceSetNamePattern
             `sourceSetNamePattern` определяет naming policy зарегистрированного source set.
             Default:
             - `{variant}{layerCap}`
             Tokens:
             - `{variant}`, `{variantCap}`
             - `{role}`, `{roleCap}`
             - `{layer}`, `{layerCap}`
             Имя санитизируется (`[^A-Za-z0-9_.-] -> _`).
             Ограничение:
             - один `sourceSetName` не может быть порожден разными слоями.
             ## EVENTS
             ### whenRegistered
             - callback на новый уникальный source set;
             - replayable;
             - при shared source set срабатывает один раз.
             ### whenBound
             - callback на каждую usage-связку `variant/role/layer`;
             - replayable;
             - подходит для per-usage логики.
             ### variant filter
-            Глобальные callbacks поддерживают фильтр по варианту:
+            Фильтр по варианту поддерживает только usage-binding:
-            - `whenRegistered(String variantName, ...)`
             - `whenBound(String variantName, ...)`
-            ## SOURCE SET CONTEXT
+            ## PAYLOAD TYPES
+            `SourceSetRegistration` содержит:
-            `SourceSetContext` содержит:
+            - `layerName`, `sourceSetName`;
+            - `sourceSet` (`NamedDomainObjectProvider<GenericSourceSet>`).
+            Sugar:
+            - `configureSourceSet(Action|Closure)`.
+            `SourceSetUsageBinding` содержит:
             - `variantName`, `roleName`, `layerName`, `sourceSetName`;
             - `sourceSet` (`NamedDomainObjectProvider<GenericSourceSet>`).
             Sugar:
             - `configureSourceSet(Action|Closure)`.
             ## API
             ### VariantSourcesExtension
             - `bind(String)` — получить/создать binding по имени слоя.
             - `bind(String, Action|Closure)` — сконфигурировать binding.
             - `bindings(Action|Closure)` — контейнерная конфигурация bindings.
             - `whenRegistered(...)` — глобальные callbacks регистрации source set.
             - `whenBound(...)` — глобальные callbacks usage-binding.
+            - `whenBound(String variantName, ...)` — usage-binding callbacks с variant-filter.
             ### BuildLayerBinding
             - `sourceSetNamePattern` — naming policy для source set слоя.
             - `configureSourceSet(...)` — слойная конфигурация `GenericSourceSet`.
             - `whenRegistered(...)` — callbacks регистрации в рамках слоя.
             - `whenBound(...)` — callbacks usage-binding в рамках слоя.
             ## KEY CLASSES
             - `VariantsSourcesPlugin` — точка входа plugin adapter.
             - `VariantSourcesExtension` — глобальный DSL bind/events.
             - `BuildLayerBinding` — layer-local policy и callbacks.
-            - `SourceSetContext` — payload callbacks и sugar-конфигурирование.
+            - `SourceSetRegistration` — payload регистрации source set.
+            - `SourceSetUsageBinding` — payload usage-binding.
             ## NOTES
             - `sourceSetNamePattern` фиксируется при первом чтении в registration
               (`finalizeValueOnRead`).
             - Closure callbacks используют delegate-first.
             - Для вложенных closure лучше явный параметр (`ctx -> ...`).

common/src/main/java/org/implab/gradle/common/sources/SourceSetContext.java removed 0 -41

	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