implab/gradle-common Commit - r27:33c11dfc2c2e

Variants mutation guard after finalize

cin -

r27:33c11dfc2c2e default

parent child

Context file:

r27:33c11dfc2c2e

Collapse all files

common/src/main/java/org/implab/gradle/common/sources/LayerLink.java created 644 +7 0

@@ -0,0 +1,7
	1	package org.implab.gradle.common.sources;
	2
	3	/**
	4	* Directed relation between two layers within a variant.
	5	*/
	6	public record LayerLink(String from, String to, String kind) {
	7	}

common/readme.md +9 -9

             ## NAME
             `gradle-common/common` — набор плагинов для моделирования вариантов сборки,
-            материализации source sets и интеграции этой модели с toolchain-адаптерами.
+            регистрации source sets и интеграции этой модели с toolchain-адаптерами.
             ## SYNOPSIS
             Модуль состоит из трех логических частей:
             - `variants` — декларативная доменная модель сборки;
-            - `sources` — модель физически материализуемых source sets;
+            - `sources` — модель физически регистрируемых source sets;
             - `variantSources` — адаптер, который связывает первые две модели.
             Ниже раскрытие каждой части.
             ### variantSources
-            `variantSources` материализует source sets на основе `variants`, применяет
+            `variantSources` регистрирует source sets на основе `variants`, применяет
             конфигурацию layer-bindings и отдает события (`whenRegistered`, `whenBound`) для
             адаптеров других плагинов.
             Практический смысл:
             - переводить логическую модель `variants` в executable-модель `sources`;
-            - навешивать политики toolchain на materialized source sets;
+            - навешивать политики toolchain на зарегистрированные source sets;
             - синхронизировать плагины через replayable callback-контракт.
             ## DOMAIN MODEL
             - `BuildLayer` — глобальный идентификатор слоя.
             - `BuildVariant` — агрегат ролей, связей, атрибутов, артефактных слотов.
             - `BuildRole` — роль внутри варианта, содержит ссылки на layer names.
-            - `BuildLink` — ориентированная связь `from -> to` в графе определенного `kind`.
+            - `LayerLink` — ориентированная связь `from -> to` в графе определенного `kind`.
-            - `GenericSourceSet` — materialized набор исходников и outputs.
+            - `GenericSourceSet` — зарегистрированный набор исходников и outputs.
-            - `BuildLayerBinding` — правила materialization source set для конкретного layer.
+            - `BuildLayerBinding` — правила registration source set для конкретного layer.
-            - `SourceSetContext` — контекст callback-событий materialization.
+            - `SourceSetContext` — контекст callback-событий registration.
             ## EVENT CONTRACT
             - `BuildVariantsExtension` — корневой API модели вариантов.
             - `BuildVariant` — API ролей, links, attributes и artifact slots варианта.
             - `VariantsSourcesPlugin` — применяет `variants` + `sources` и запускает адаптер.
-            - `VariantSourcesExtension` — API bind/events materialization.
+            - `VariantSourcesExtension` — API bind/events registration.
             - `BuildLayerBinding` — слой-конкретный DSL для имени и конфигурации source set.
             - `SourceSetContext` — payload событий и sugar `configureSourceSet(...)`.

common/src/main/java/org/implab/gradle/common/sources/BuildRole.java +18 0

             import javax.inject.Inject;
+            import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.provider.ListProperty;
              */
             public abstract class BuildRole implements Named {
                 private final String name;
+                private boolean finalized;
                 @Inject
                 public BuildRole(String name) {
                  * Binds this role to one or more declared layers.
                  */
                 public void layers(String layer, String... extra) {
+                    ensureMutable("add role layers");
                     var values = new ArrayList<String>(1 + extra.length);
                     values.add(Objects.requireNonNull(layer, "Layer name is required"));
                     getLayers().addAll(values);
                 }
+                void finalizeModel() {
+                    if (finalized)
+                        return;
+                    getLayers().finalizeValue();
+                    getLayers().disallowChanges();
+                    finalized = true;
+                }
+                private void ensureMutable(String operation) {
+                    if (finalized)
+                        throw new InvalidUserDataException("Role '" + name + "' is finalized and cannot " + operation);
+                }
             }

common/src/main/java/org/implab/gradle/common/sources/BuildVariant.java +35 -59

             package org.implab.gradle.common.sources;
+            import java.util.ArrayList;
             import java.util.Collection;
             import java.util.Collections;
             import java.util.LinkedHashMap;
             import java.util.LinkedHashSet;
+            import java.util.List;
             import java.util.Set;
-            import java.util.regex.Pattern;
             import javax.inject.Inject;
             import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
+            import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Provider;
             import groovy.lang.Closure;
             public abstract class BuildVariant implements Named {
-                private static final Pattern INVALID_NAME_CHAR = Pattern.compile("[^A-Za-z0-9_.-]");
                 private final String name;
                 private final ObjectFactory objects;
+                private boolean finalized;
                 /**
                  * Variant aggregate parts.
                  */
                 private final VariantAttributes attributes;
                 private final LinkedHashMap<String, BuildRole> roles = new LinkedHashMap<>();
-                private final LinkedHashMap<String, BuildLink> links = new LinkedHashMap<>();
+                private final List<LayerLink> links = new ArrayList<>();
                 private final LinkedHashMap<String, BuildArtifactSlot> artifactSlots = new LinkedHashMap<>();
                 @Inject
                 }
                 public void attributes(Action<? super AttributesSpec> action) {
+                    ensureMutable("configure attributes");
                     action.execute(new AttributesSpec(attributes));
                 }
                 }
                 public <T> void attribute(Attribute<T> key, T value) {
+                    ensureMutable("set attributes");
                     attributes.attribute(key, value);
                 }
                 public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
+                    ensureMutable("set attributes");
                     attributes.attributeProvider(key, value);
                 }
                 }
                 public void roles(Action<? super RolesSpec> action) {
+                    ensureMutable("configure roles");
                     action.execute(new RolesSpec());
                 }
                 }
                 public BuildRole role(String name, Action<? super BuildRole> configure) {
+                    ensureMutable("configure roles");
                     var role = roles.computeIfAbsent(name, this::newRole);
                     configure.execute(role);
                     return role;
                     return roles.get(name);
                 }
-                public Collection<BuildLink> getLinks() {
+                public Collection<LayerLink> getLinks() {
-                    return Collections.unmodifiableCollection(links.values());
+                    return Collections.unmodifiableList(links);
                 }
                 public void links(Action<? super LinksSpec> action) {
+                    ensureMutable("configure links");
                     action.execute(new LinksSpec());
                 }
                     links(Closures.action(configure));
                 }
-                public BuildLink link(String from, String to, String kind, Action<? super BuildLink> configure) {
+                public LayerLink link(String from, String to, String kind) {
-                    return link(defaultLinkName(from, to, kind), link -> {
+                    ensureMutable("add links");
-                        link.from(from);
+                    var link = new LayerLink(from, to, kind);
-                        link.to(to);
+                    links.add(link);
-                        link.kind(kind);
-                        configure.execute(link);
-                    });
-                public BuildLink link(String from, String to, String kind, Closure<?> configure) {
-                    return link(from, to, kind, Closures.action(configure));
-                public BuildLink link(String from, String to, String kind) {
-                    return link(from, to, kind, it -> {
-                    });
-                public BuildLink link(String name, Action<? super BuildLink> configure) {
-                    var link = links.computeIfAbsent(name, this::newLink);
-                    configure.execute(link);
                     return link;
                 }
-                public BuildLink link(String name, Closure<?> configure) {
-                    return link(name, Closures.action(configure));
-                public BuildLink getLinkByName(String name) {
-                    return links.get(name);
                 public Collection<BuildArtifactSlot> getArtifactSlots() {
                     return Collections.unmodifiableCollection(artifactSlots.values());
                 }
                 public void artifactSlots(Action<? super ArtifactSlotsSpec> action) {
+                    ensureMutable("configure artifact slots");
                     action.execute(new ArtifactSlotsSpec());
                 }
                 }
                 public BuildArtifactSlot artifactSlot(String name, Action<? super BuildArtifactSlot> configure) {
+                    ensureMutable("configure artifact slots");
                     var slot = artifactSlots.computeIfAbsent(name, this::newArtifactSlot);
                     configure.execute(slot);
                     return slot;
                     return result;
                 }
+                void finalizeModel() {
+                    if (finalized)
+                        return;
+                    for (var role : roles.values())
+                        role.finalizeModel();
+                    attributes.finalizeModel();
+                    finalized = true;
+                }
                 private BuildRole newRole(String roleName) {
                     return objects.newInstance(BuildRole.class, roleName);
                 }
-                private BuildLink newLink(String linkName) {
-                    return objects.newInstance(BuildLink.class, linkName);
                 private BuildArtifactSlot newArtifactSlot(String slotName) {
                     return objects.newInstance(BuildArtifactSlot.class, slotName);
                 }
-                private static String defaultLinkName(String from, String to, String kind) {
+                private void ensureMutable(String operation) {
-                    return "link_" + sanitize(from) + "__" + sanitize(to) + "__" + sanitize(kind);
+                    if (finalized)
+                        throw new InvalidUserDataException("Variant '" + name + "' is finalized and cannot " + operation);
-                private static String sanitize(String value) {
-                    return INVALID_NAME_CHAR.matcher(String.valueOf(value)).replaceAll("_");
                 }
                 public final class RolesSpec {
                 }
                 public final class LinksSpec {
-                    public BuildLink link(String from, String to, String kind, Action<? super BuildLink> configure) {
+                    public LayerLink link(String from, String to, String kind) {
-                        return BuildVariant.this.link(from, to, kind, configure);
-                    public BuildLink link(String from, String to, String kind, Closure<?> configure) {
-                        return BuildVariant.this.link(from, to, kind, configure);
-                    public BuildLink link(String from, String to, String kind) {
                         return BuildVariant.this.link(from, to, kind);
                     }
-                    public Collection<BuildLink> getAll() {
+                    public Collection<LayerLink> getAll() {
                         return BuildVariant.this.getLinks();
                     }
-                    public BuildLink getByName(String name) {
-                        return BuildVariant.this.getLinkByName(name);
                 }
                 public final class ArtifactSlotsSpec {

common/src/main/java/org/implab/gradle/common/sources/BuildVariantsExtension.java +31 -7

                 public BuildVariantsExtension(ObjectFactory objects) {
                     layers = objects.domainObjectContainer(BuildLayer.class);
                     variants = objects.domainObjectContainer(BuildVariant.class);
+                    layers.all(layer -> {
+                        if (finalized)
+                            throw new InvalidUserDataException(
+                                    "Variants model is finalized and cannot add layer '" + layer.getName() + "'");
+                    });
+                    variants.all(variant -> {
+                        if (finalized)
+                            throw new InvalidUserDataException(
+                                    "Variants model is finalized and cannot add variant '" + variant.getName() + "'");
+                    });
                 }
                 public NamedDomainObjectContainer<BuildLayer> getLayers() {
                 }
                 public void layers(Action<? super NamedDomainObjectContainer<BuildLayer>> action) {
+                    ensureMutable("configure layers");
                     action.execute(layers);
                 }
                 }
                 public void variants(Action<? super NamedDomainObjectContainer<BuildVariant>> action) {
+                    ensureMutable("configure variants");
                     action.execute(variants);
                 }
                 }
                 public BuildLayer layer(String name, Action<? super BuildLayer> configure) {
+                    ensureMutable("configure layers");
                     var layer = layers.maybeCreate(name);
                     configure.execute(layer);
                     return layer;
                 }
                 public BuildVariant variant(String name, Action<? super BuildVariant> configure) {
+                    ensureMutable("configure variants");
                     var variant = variants.maybeCreate(name);
                     configure.execute(variant);
                     return variant;
                         return;
                     validate();
+                    for (var variant : variants)
+                        variant.finalizeModel();
                     finalized = true;
                     var actions = new ArrayList<>(finalizedActions);
                     var edgesByKind = new HashMap<String, Map<String, Set<String>>>();
                     for (var link : variant.getLinks()) {
-                        var from = normalize(link.getFrom().getOrNull());
+                        var from = normalize(link.from());
-                        var to = normalize(link.getTo().getOrNull());
+                        var to = normalize(link.to());
-                        var kind = normalize(link.getKind().getOrNull());
+                        var kind = normalize(link.kind());
                         if (from == null || to == null || kind == null) {
-                            errors.add("Variant '" + variant.getName() + "' has incomplete link '" + link.getName()
+                            errors.add("Variant '" + variant.getName() + "' has incomplete link (from/to/kind are required)");
-                                    + "' (from/to/kind are required)");
                             continue;
                         }
                         if (!variantLayers.contains(from)) {
-                            errors.add("Variant '" + variant.getName() + "' link '" + link.getName() + "' references unknown source layer '"
+                            errors.add("Variant '" + variant.getName() + "' link references unknown source layer '"
                                     + from + "'");
                             continue;
                         }
                         if (!variantLayers.contains(to)) {
-                            errors.add("Variant '" + variant.getName() + "' link '" + link.getName() + "' references unknown target layer '"
+                            errors.add("Variant '" + variant.getName() + "' link references unknown target layer '"
                                     + to + "'");
                             continue;
                         }
                 private static boolean isBlank(String value) {
                     return normalize(value) == null;
                 }
+                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/SourcesPlugin.java +6 -2

                 @Override
                 public void apply(Project target) {
+                    logger.debug("Registering '{}' extension on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                     var sources = target.getObjects().domainObjectContainer(GenericSourceSet.class);
                     target.getExtensions().add(SOURCES_EXTENSION_NAME, sources);
                 }
                     var extensions = target.getExtensions();
                     @SuppressWarnings("unchecked")
-                    var extension = (NamedDomainObjectContainer<GenericSourceSet>)extensions.getByName(SOURCES_EXTENSION_NAME);
+                    var extension = (NamedDomainObjectContainer<GenericSourceSet>) extensions.findByName(SOURCES_EXTENSION_NAME);
-                    if (extension == null)
+                    if (extension == null) {
+                        logger.error("Sources extension '{}' isn't found on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                         throw new GradleException("Sources extension isn't found");
+                    }
+                    logger.debug("Resolved '{}' extension on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                     return extension;
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantAttributes.java +13 0

             import java.util.LinkedHashMap;
             import java.util.Map;
+            import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.attributes.Attribute;
             import org.gradle.api.provider.ProviderFactory;
             import org.gradle.api.provider.Provider;
             public final class VariantAttributes {
                 private final ProviderFactory providers;
                 private final LinkedHashMap<Attribute<?>, Provider<?>> values = new LinkedHashMap<>();
+                private boolean finalized;
                 VariantAttributes(ProviderFactory providers) {
                     this.providers = providers;
                 }
                 public <T> void attribute(Attribute<T> key, T value) {
+                    ensureMutable("set attribute '" + key.getName() + "'");
                     attributeProvider(key, providers.provider(() -> value));
                 }
                 public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
+                    ensureMutable("set attribute provider '" + key.getName() + "'");
                     values.put(key, value);
                 }
                 public Map<Attribute<?>, Provider<?>> asMap() {
                     return Collections.unmodifiableMap(values);
                 }
+                void finalizeModel() {
+                    finalized = true;
+                }
+                private void ensureMutable(String operation) {
+                    if (finalized)
+                        throw new InvalidUserDataException("Variant attributes are finalized and cannot " + operation);
+                }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantSourcesExtension.java +24 -3

             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;
             /**
-             * Adapter extension that materializes source sets for variant/layer pairs.
+             * 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 INVALID_NAME_CHAR = Pattern.compile("[^A-Za-z0-9_.-]");
                 private static final Pattern SOURCE_SET_NAME_TOKEN = Pattern.compile("\\{([A-Za-z][A-Za-z0-9]*)\\}");
                 void registerSourceSets(BuildVariantsExtension variants, NamedDomainObjectContainer<GenericSourceSet> sources) {
                     validateBindings(variants);
-                    layerUsages(variants).forEach(usage -> materializeLayerUsage(usage, sources));
+                    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());
                 }
                 private Stream<LayerUsage> layerUsages(BuildVariantsExtension variants) {
                                                     normalize(layerName)))));
                 }
-                private void materializeLayerUsage(LayerUsage usage, NamedDomainObjectContainer<GenericSourceSet> sources) {
+                private void registerLayerUsage(LayerUsage usage, NamedDomainObjectContainer<GenericSourceSet> sources) {
                     var resolvedBinding = bind(usage.layerName());
                     var sourceSetNamePattern = resolvedBinding.getSourceSetNamePattern();
                     sourceSetNamePattern.finalizeValueOnRead();

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

             import org.gradle.api.GradleException;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
+            import org.gradle.api.logging.Logger;
+            import org.gradle.api.logging.Logging;
             /**
              * Registers {@code variants} extension for build-variant modeling.
              */
             public abstract class VariantsPlugin implements Plugin<Project> {
+                private static final Logger logger = Logging.getLogger(VariantsPlugin.class);
                 public static final String VARIANTS_EXTENSION_NAME = "variants";
                 @Override
                 public void apply(Project target) {
+                    logger.debug("Registering '{}' extension on project '{}'", VARIANTS_EXTENSION_NAME, target.getPath());
                     var variants = target.getExtensions().create(VARIANTS_EXTENSION_NAME, BuildVariantsExtension.class);
-                    target.afterEvaluate(project -> variants.finalizeModel());
+                    target.afterEvaluate(project -> {
+                        logger.debug("Finalizing variants model on project '{}'", project.getPath());
+                        variants.finalizeModel();
+                        logger.debug("Variants model finalized on project '{}'", project.getPath());
+                    });
                 }
                 public static BuildVariantsExtension getVariantsExtension(Project target) {
                     var extension = target.getExtensions().findByType(BuildVariantsExtension.class);
-                    if (extension == null)
+                    if (extension == null) {
+                        logger.error("Variants extension '{}' isn't found on project '{}'", VARIANTS_EXTENSION_NAME, target.getPath());
                         throw new GradleException("Variants extension isn't found");
+                    }
+                    logger.debug("Resolved '{}' extension on project '{}'", VARIANTS_EXTENSION_NAME, target.getPath());
                     return extension;
                 }

common/src/main/java/org/implab/gradle/common/sources/VariantsSourcesPlugin.java +10 -2

             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
+            import org.gradle.api.logging.Logger;
+            import org.gradle.api.logging.Logging;
             /**
-             * Binds variant layers to materialized source sets.
+             * Binds variant layers to registered source sets.
              */
             public abstract class VariantsSourcesPlugin implements Plugin<Project> {
+                private static final Logger logger = Logging.getLogger(VariantsSourcesPlugin.class);
                 public static final String VARIANT_SOURCES_EXTENSION_NAME = "variantSources";
                 @Override
                 public void apply(Project target) {
+                    logger.debug("Applying variant-sources plugin on project '{}'", target.getPath());
                     target.getPluginManager().apply(VariantsPlugin.class);
                     target.getPluginManager().apply(SourcesPlugin.class);
                     var variantSources = target.getExtensions()
                             .create(VARIANT_SOURCES_EXTENSION_NAME, VariantSourcesExtension.class);
-                    variants.whenFinalized(model -> variantSources.registerSourceSets(model, sources));
+                    variants.whenFinalized(model -> {
+                        logger.debug("Registering source sets for variants on project '{}'", target.getPath());
+                        variantSources.registerSourceSets(model, sources);
+                        logger.debug("Registered source sets on project '{}'", target.getPath());
+                    });
                 }
             }

common/src/test/java/org/implab/gradle/common/sources/VariantsPluginFunctionalTest.java +46 -25

@@ -153,13 +153,10 class VariantsPluginFunctionalTest {
153	role('main') {	153	role('main') {
154	layers('a', 'b')	154	layers('a', 'b')
155	}	155	}
156	link('~~l1') {~~	156	link('a', 'b', null)
157	from('a')
158	to('b')
159	}
160	}	157	}
161	}	158	}
162	""", "has incomplete link ~~'l1'~~");	159	""", "has incomplete link (from/to/kind are required)");
163	}	160	}
164		161
165	@Test	162	@Test
@@ -177,16 +174,8 class VariantsPluginFunctionalTest {
177	role('main') {	174	role('main') {
178	layers('a', 'b')	175	layers('a', 'b')
179	}	176	}
180	link('~~first') {~~	177	link('a', 'b', 'ts:api')
181	~~from(~~'a')	178	link('a', 'b', 'ts:api')
182	to('b')
183	kind('ts:api')
184	}
185	link('second') {
186	from('a')
187	to('b')
188	kind('ts:api')
189	}
190	}	179	}
191	}	180	}
192	""", "has duplicated link tuple (from='a', to='b', kind='ts:api')");	181	""", "has duplicated link tuple (from='a', to='b', kind='ts:api')");
@@ -207,11 +196,7 class VariantsPluginFunctionalTest {
207	role('main') {	196	role('main') {
208	layers('a')	197	layers('a')
209	}	198	}
210	link('~~l1') {~~	199	link('missing', 'a', 'ts:api')
211	from('missing')
212	to('a')
213	kind('ts:api')
214	}
215	}	200	}
216	}	201	}
217	""", "references unknown source layer 'missing'");	202	""", "references unknown source layer 'missing'");
@@ -232,16 +217,52 class VariantsPluginFunctionalTest {
232	role('main') {	217	role('main') {
233	layers('a')	218	layers('a')
234	}	219	}
235	link('~~l1') {~~	220	link('a', 'missing', 'ts:api')
236	from('a')
237	to('missing')
238	kind('ts:api')
239	}
240	}	221	}
241	}	222	}
242	""", "references unknown target layer 'missing'");	223	""", "references unknown target layer 'missing'");
243	}	224	}
244		225
		226	@Test
		227	void failsOnLateLayerMutationAfterFinalize() throws Exception {
		228	assertBuildFails("""
		229	plugins {
		230	id 'org.implab.gradle-variants'
		231	}
		232
		233	variants {
		234	layer('a')
		235	variant('browser') {
		236	role('main') { layers('a') }
		237	}
		238	}
		239
		240	afterEvaluate {
		241	variants.layer('late')
		242	}
		243	""", "Variants model is finalized and cannot configure layers");
		244	}
		245
		246	@Test
		247	void failsOnLateVariantMutationAfterFinalize() throws Exception {
		248	assertBuildFails("""
		249	plugins {
		250	id 'org.implab.gradle-variants'
		251	}
		252
		253	variants {
		254	layer('a')
		255	variant('browser') {
		256	role('main') { layers('a') }
		257	}
		258	}
		259
		260	afterEvaluate {
		261	variants.getByName('browser').role('late') { layers('a') }
		262	}
		263	""", "Variant 'browser' is finalized and cannot configure roles");
		264	}
		265
245	private GradleRunner runner(String... arguments) {	266	private GradleRunner runner(String... arguments) {
246	return GradleRunner.create()	267	return GradleRunner.create()
247	.withProjectDir(testProjectDir.toFile())	268	.withProjectDir(testProjectDir.toFile())

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

                 Path testProjectDir;
                 @Test
-                void materializesVariantSourceSetsAndFiresCallbacks() throws Exception {
+                void registersVariantSourceSetsAndFiresCallbacks() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                 }
                 @Test
-                void replaysLateBindingsAndCallbacksAfterMaterialization() throws Exception {
+                void replaysLateBindingsAndCallbacksAfterRegistration() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {

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

             ## DESCRIPTION
             `VariantsSourcesPlugin` применяет `VariantsPlugin` и `SourcesPlugin`, затем
-            материализует source sets из модели `variants`.
+            регистрирует source sets из модели `variants`.
-            Точка запуска materialization:
+            Точка запуска registration:
             - `variants.whenFinalized(model -> registerSourceSets(...))`
-            ### materialization
+            ### registration
             Для каждой usage-связки `variant/role/layer` вычисляется имя source set,
             регистрируется `GenericSourceSet` (если он еще не существует), затем
             ### sourceSetNamePattern
-            `sourceSetNamePattern` определяет naming policy materialized source set.
+            `sourceSetNamePattern` определяет naming policy зарегистрированного source set.
             Default:
             ## NOTES
-            - `sourceSetNamePattern` фиксируется при первом чтении в materialization
+            - `sourceSetNamePattern` фиксируется при первом чтении в registration
               (`finalizeValueOnRead`).
             - Closure callbacks используют delegate-first.
             - Для вложенных closure лучше явный параметр (`ctx -> ...`).

common/variants-plugin.md +2 -1

             ## LIFECYCLE
             - `VariantsPlugin` вызывает `variants.finalizeModel()` на `afterEvaluate`.
+            - после `finalizeModel()` мутации модели запрещены.
             - `whenFinalized(...)` replayable.
             ## API
             - `BuildVariant` — агрегатная модель варианта.
             - `BuildLayer` — модель слоя.
             - `BuildRole` — модель роли.
-            - `BuildLink` — модель направленной связи.
+            - `LayerLink` — модель направленной связи.
             - `BuildArtifactSlot` — модель артефактного слота.
             - `VariantAttributes` — typed wrapper для variant attributes.

common/src/main/java/org/implab/gradle/common/sources/BuildLink.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