implab/gradle-common Commit - r30:2dd3356774b2

Removed layer links from variants

cin -

r30:2dd3356774b2 default

parent child

Context file:

r30:2dd3356774b2

Collapse all files

common/readme.md +4 -7

                 variant('browser') {
                     role('main') { layers('mainBase', 'mainAmd') }
-                    link('mainBase', 'mainAmd', 'ts:api')
                 }
             }
             ### variants
             `variants` задает структуру пространства сборки: какие есть слои, какие роли
-            используют эти слои в каждом варианте, какие направленные связи между слоями
+            используют эти слои в каждом варианте, какие есть атрибуты и artifact slots.
-            существуют. Модель не создает задачи и не привязана к TS/JS.
+            Модель не создает задачи и не привязана к TS/JS.
             Практический смысл:
             - формализовать архитектуру сборки;
-            - централизовать валидацию связей;
             - дать адаптерам единый источник правды.
             ### sources
             ## DOMAIN MODEL
             - `BuildLayer` — глобальный идентификатор слоя.
-            - `BuildVariant` — агрегат ролей, связей, атрибутов, артефактных слотов.
+            - `BuildVariant` — агрегат ролей, атрибутов, артефактных слотов.
             - `BuildRole` — роль внутри варианта, содержит ссылки на layer names.
-            - `LayerLink` — ориентированная связь `from -> to` в графе определенного `kind`.
             - `GenericSourceSet` — зарегистрированный набор исходников и outputs.
             - `BuildLayerBinding` — правила registration source set для конкретного layer.
             - `SourceSetContext` — контекст callback-событий registration.
             - `GenericSourceSet` — модель источников/outputs для конкретного имени.
             - `VariantsPlugin` — регистрирует extension `variants` и lifecycle finalize.
             - `BuildVariantsExtension` — корневой API модели вариантов.
-            - `BuildVariant` — API ролей, links, attributes и artifact slots варианта.
+            - `BuildVariant` — API ролей, attributes и artifact slots варианта.
             - `VariantsSourcesPlugin` — применяет `variants` + `sources` и запускает адаптер.
             - `VariantSourcesExtension` — API bind/events registration.
             - `BuildLayerBinding` — слой-конкретный DSL для имени и конфигурации source set.

common/src/main/java/org/implab/gradle/common/core/lang/Strings.java +11 0

                 private static final Pattern firstLetter = Pattern.compile("^\\w");
+                private static final Pattern INVALID_NAME_CHAR = Pattern.compile("[^A-Za-z0-9_.-]");
                 public static String capitalize(String string) {
                     return string == null ? null
                             : string.length() == 0 ? string
                         throw new IllegalArgumentException(String.format("Argument %s can't be null or empty", argumentName));
                 }
+                public static void argumentNotNullOrBlank(String value, String argumentName) {
+                    if (value == null || value.trim().length() == 0)
+                        throw new IllegalArgumentException(String.format("Argument %s can't be null or blank", argumentName));
+                }
+                public static String sanitizeName(String value) {
+                    return INVALID_NAME_CHAR.matcher(value).replaceAll("_");
+                }
                 public static String asString(Object value) {
                     if (value == null)
                         return null;

common/src/main/java/org/implab/gradle/common/sources/BuildVariant.java 0 -43

             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.List;
             import java.util.Optional;
             import javax.inject.Inject;
                  */
                 private final VariantAttributes attributes;
                 private final LinkedHashMap<String, BuildRole> roles = new LinkedHashMap<>();
-                private final List<LayerLink> links = new ArrayList<>();
                 private final LinkedHashMap<String, BuildArtifactSlot> artifactSlots = new LinkedHashMap<>();
                 @Inject
                                     "Variant '" + this.name + "' doesn't define role '" + name + "'"));
                 }
-                public Collection<LayerLink> getLinks() {
-                    return Collections.unmodifiableList(links);
-                public void links(Action<? super LinksSpec> action) {
-                    ensureMutable("configure links");
-                    action.execute(new LinksSpec());
-                public void links(Closure<?> configure) {
-                    links(Closures.action(configure));
-                public LayerLink link(String from, String to, String kind) {
-                    ensureMutable("add links");
-                    var link = new LayerLink(
-                            requireLinkValue("from", from),
-                            requireLinkValue("to", to),
-                            requireLinkValue("kind", kind));
-                    links.add(link);
-                    return link;
                 public Collection<BuildArtifactSlot> getArtifactSlots() {
                     return Collections.unmodifiableCollection(artifactSlots.values());
                 }
                         throw new InvalidUserDataException("Variant '" + name + "' is finalized and cannot " + operation);
                 }
-                private static String requireLinkValue(String field, String value) {
-                    if (value == null || value.trim().isEmpty())
-                        throw new InvalidUserDataException("Link '" + field + "' must not be null or blank");
-                    return value.trim();
                 public final class RolesSpec {
                     public BuildRole role(String name, Action<? super BuildRole> configure) {
                         return BuildVariant.this.role(name, configure);
                     }
                 }
-                public final class LinksSpec {
-                    public LayerLink link(String from, String to, String kind) {
-                        return BuildVariant.this.link(from, to, kind);
-                    public Collection<LayerLink> getAll() {
-                        return BuildVariant.this.getLinks();
                 public final class ArtifactSlotsSpec {
                     public BuildArtifactSlot artifactSlot(String name, Action<? super BuildArtifactSlot> configure) {
                         return BuildVariant.this.artifactSlot(name, configure);

common/src/main/java/org/implab/gradle/common/sources/BuildVariantsExtension.java +2 -91

@@ -3,14 +3,11 package org.implab.gradle.common.sources
3	import java.util.ArrayList;	3	import java.util.ArrayList;
4	import java.util.Collection;	4	import java.util.Collection;
5	import java.util.Collections;	5	import java.util.Collections;
6	import java.util.HashMap;
7	import java.util.HashSet;
8	import java.util.LinkedHashMap;	6	import java.util.LinkedHashMap;
9	import java.util.LinkedHashSet;	7	import java.util.LinkedHashSet;
10	import java.util.List;	8	import java.util.List;
11	import java.util.Map;	9	import java.util.Map;
12	import java.util.Optional;	10	import java.util.Optional;
13	import java.util.Set;
14		11
15	import javax.inject.Inject;	12	import javax.inject.Inject;
16		13
@@ -197,8 +194,7 public abstract class BuildVariantsExten
197	}	194	}
198		195
199	validateRoleAndArtifactNames(variant, errors);	196	validateRoleAndArtifactNames(variant, errors);
200	~~var~~ ~~variantLayers~~ = validateRoleMappings(variant, layersByName, errors);	197	validateRoleMappings(variant, layersByName, errors);
201	validateLinks(variant, variantLayers, errors);
202	}	198	}
203		199
204	private static void validateRoleAndArtifactNames(BuildVariant variant, List<String> errors) {	200	private static void validateRoleAndArtifactNames(BuildVariant variant, List<String> errors) {
@@ -227,10 +223,8 public abstract class BuildVariantsExten
227	}	223	}
228	}	224	}
229		225
230	private static ~~Set~~<~~String~~> validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,	226	private static void validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,
231	List<String> errors) {	227	List<String> errors) {
232	var variantLayers = new LinkedHashSet<String>();
233
234	for (var role : variant.getRoles()) {	228	for (var role : variant.getRoles()) {
235	var seenLayers = new LinkedHashSet<String>();	229	var seenLayers = new LinkedHashSet<String>();
236	for (var layerName : role.getLayers().getOrElse(List.of())) {	230	for (var layerName : role.getLayers().getOrElse(List.of())) {
@@ -249,88 +243,9 public abstract class BuildVariantsExten
249	if (!seenLayers.add(normalizedLayerName)) {	243	if (!seenLayers.add(normalizedLayerName)) {
250	errors.add("Variant '" + variant.getName() + "', role '" + role.getName()	244	errors.add("Variant '" + variant.getName() + "', role '" + role.getName()
251	+ "' contains duplicated layer reference '" + normalizedLayerName + "'");	245	+ "' contains duplicated layer reference '" + normalizedLayerName + "'");
252	continue;
253	}
254
255	variantLayers.add(normalizedLayerName);
256	}
257	}
258
259	return variantLayers;
260	}
261
262	private static void validateLinks(BuildVariant variant, Set<String> variantLayers, List<String> errors) {
263	var seenLinks = new HashSet<String>();
264	var edgesByKind = new HashMap<String, Map<String, Set<String>>>();
265
266	for (var link : variant.getLinks()) {
267	var from = normalize(link.from());
268	var to = normalize(link.to());
269	var kind = normalize(link.kind());
270
271	if (from == null \|\| to == null \|\| kind == null) {
272	errors.add("Variant '" + variant.getName() + "' has incomplete link (from/to/kind are required)");
273	continue;
274	}
275
276	if (!variantLayers.contains(from)) {
277	errors.add("Variant '" + variant.getName() + "' link references unknown source layer '"
278	+ from + "'");
279	continue;
280	}
281
282	if (!variantLayers.contains(to)) {
283	errors.add("Variant '" + variant.getName() + "' link references unknown target layer '"
284	+ to + "'");
285	continue;
286	}
287
288	var linkKey = from + "\u0000" + to + "\u0000" + kind;
289	if (!seenLinks.add(linkKey)) {
290	errors.add("Variant '" + variant.getName() + "' has duplicated link tuple (from='" + from
291	+ "', to='" + to + "', kind='" + kind + "')");
292	}
293
294	edgesByKind
295	.computeIfAbsent(kind, x -> new LinkedHashMap<>())
296	.computeIfAbsent(from, x -> new LinkedHashSet<>())
297	.add(to);
298	}
299
300	for (var entry : edgesByKind.entrySet()) {
301	if (hasCycle(variantLayers, entry.getValue())) {
302	errors.add("Variant '" + variant.getName() + "' contains cycle in links with kind '" + entry.getKey() + "'");
303	}	246	}
304	}	247	}
305	}	248	}
306
307	private static boolean hasCycle(Set<String> nodes, Map<String, Set<String>> edges) {
308	var state = new HashMap<String, Integer>();
309
310	for (var node : nodes) {
311	if (dfs(node, state, edges))
312	return true;
313	}
314
315	return false;
316	}
317
318	private static boolean dfs(String node, Map<String, Integer> state, Map<String, Set<String>> edges) {
319	var current = state.getOrDefault(node, 0);
320	if (current == 1)
321	return true;
322	if (current == 2)
323	return false;
324
325	state.put(node, 1);
326
327	for (var next : edges.getOrDefault(node, Set.of())) {
328	if (dfs(next, state, edges))
329	return true;
330	}
331
332	state.put(node, 2);
333	return false;
334	}	249	}
335		250
336	private static String normalize(String value) {	251	private static String normalize(String value) {
@@ -341,10 +256,6 public abstract class BuildVariantsExten
341	return trimmed.isEmpty() ? null : trimmed;	256	return trimmed.isEmpty() ? null : trimmed;
342	}	257	}
343		258
344	private static boolean isBlank(String value) {
345	return normalize(value) == null;
346	}
347
348	private void ensureMutable(String operation) {	259	private void ensureMutable(String operation) {
349	if (finalized)	260	if (finalized)
350	throw new InvalidUserDataException("Variants model is finalized and cannot " + operation);	261	throw new InvalidUserDataException("Variants model is finalized and cannot " + operation);

common/src/main/java/org/implab/gradle/common/sources/VariantSourcesExtension.java +13 -21

             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 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 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]*)\\}");
-                private final ObjectFactory objects;
                 private final NamedDomainObjectContainer<BuildLayerBinding> bindings;
                 private final List<Action<? super SourceSetContext>> registeredActions = new ArrayList<>();
                 private final List<Action<? super SourceSetContext>> boundActions = new ArrayList<>();
                 @Inject
                 public VariantSourcesExtension(ObjectFactory objects) {
-                    this.objects = objects;
                     bindings = objects.domainObjectContainer(BuildLayerBinding.class);
                 }
                 }
                 public BuildLayerBinding bind(String layer) {
-                    return bindings.maybeCreate(normalize(layer));
+                    return bindings.maybeCreate(normalize(layer, "Layer name must not be null or blank"));
                 }
                 /**
                                             .map(layerName -> new LayerUsage(
                                                     variant.getName(),
                                                     role.getName(),
-                                                    normalize(layerName)))));
+                                                    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) {
                 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 = sanitize(resolved);
+                    var result = sanitizeName(resolved);
                     if (result.isEmpty())
                         throw new InvalidUserDataException("sourceSetNamePattern '" + pattern + "' resolved to empty source set name");
                 private static String tokenValue(String token, LayerUsage usage) {
                     return switch (token) {
-                        case "variant" -> sanitize(usage.variantName());
+                        case "variant" -> sanitizeName(usage.variantName());
-                        case "variantCap" -> Strings.capitalize(sanitize(usage.variantName()));
+                        case "variantCap" -> Strings.capitalize(sanitizeName(usage.variantName()));
-                        case "role" -> sanitize(usage.roleName());
+                        case "role" -> sanitizeName(usage.roleName());
-                        case "roleCap" -> Strings.capitalize(sanitize(usage.roleName()));
+                        case "roleCap" -> Strings.capitalize(sanitizeName(usage.roleName()));
-                        case "layer" -> sanitize(usage.layerName());
+                        case "layer" -> sanitizeName(usage.layerName());
-                        case "layerCap" -> Strings.capitalize(sanitize(usage.layerName()));
+                        case "layerCap" -> Strings.capitalize(sanitizeName(usage.layerName()));
                         default -> throw new InvalidUserDataException(
                                 "sourceSetNamePattern contains unsupported token '{" + token + "}'");
                     };
                 }
-                private static String sanitize(String value) {
+                private static String normalize(@Nullable String value, String errorMessage) {
-                    return INVALID_NAME_CHAR.matcher(value).replaceAll("_");
-                private static String normalize(String value) {
-                    return normalize(value, "Value must not be null or blank");
-                private static String normalize(String value, String errorMessage) {
                     if (value == null)
                         throw new InvalidUserDataException(errorMessage);
                     var trimmed = value.trim();

common/src/test/java/org/implab/gradle/common/sources/VariantsPluginFunctionalTest.java 0 -110

@@ -48,7 +48,6 class VariantsPluginFunctionalTest {
48	role('main') {	48	role('main') {
49	layers('mainBase', 'mainAmd')	49	layers('mainBase', 'mainAmd')
50	}	50	}
51	link('mainBase', 'mainAmd', 'ts:api')
52	artifactSlot('mainCompiled')	51	artifactSlot('mainCompiled')
53	}	52	}
54	}	53	}
@@ -58,7 +57,6 class VariantsPluginFunctionalTest {
58	def browser = variants.require('browser')	57	def browser = variants.require('browser')
59	println('attributes=' + browser.attributes.size())	58	println('attributes=' + browser.attributes.size())
60	println('roles=' + browser.roles.size())	59	println('roles=' + browser.roles.size())
61	println('links=' + browser.links.size())
62	println('slots=' + browser.artifactSlots.size())	60	println('slots=' + browser.artifactSlots.size())
63	}	61	}
64	}	62	}
@@ -68,7 +66,6 class VariantsPluginFunctionalTest {
68		66
69	assertTrue(result.getOutput().contains("attributes=2"));	67	assertTrue(result.getOutput().contains("attributes=2"));
70	assertTrue(result.getOutput().contains("roles=1"));	68	assertTrue(result.getOutput().contains("roles=1"));
71	assertTrue(result.getOutput().contains("links=1"));
72	assertTrue(result.getOutput().contains("slots=1"));	69	assertTrue(result.getOutput().contains("slots=1"));
73	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);	70	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
74	}	71	}
@@ -94,28 +91,6 class VariantsPluginFunctionalTest {
94	}	91	}
95		92
96	@Test	93	@Test
97	void failsOnCycleInLinksByKind() throws Exception {
98	assertBuildFails("""
99	plugins {
100	id 'org.implab.gradle-variants'
101	}
102
103	variants {
104	layer('a')
105	layer('b')
106
107	variant('browser') {
108	role('main') {
109	layers('a', 'b')
110	}
111	link('a', 'b', 'ts:api')
112	link('b', 'a', 'ts:api')
113	}
114	}
115	""", "contains cycle in links with kind 'ts:api'");
116	}
117
118	@Test
119	void allowsUsingLayerFromDifferentVariantRole() throws Exception {	94	void allowsUsingLayerFromDifferentVariantRole() throws Exception {
120	writeFile(SETTINGS_FILE, ROOT_NAME);	95	writeFile(SETTINGS_FILE, ROOT_NAME);
121	writeFile(BUILD_FILE, """	96	writeFile(BUILD_FILE, """
@@ -139,91 +114,6 class VariantsPluginFunctionalTest {
139	}	114	}
140		115
141	@Test	116	@Test
142	void failsOnIncompleteLink() throws Exception {
143	assertBuildFails("""
144	plugins {
145	id 'org.implab.gradle-variants'
146	}
147
148	variants {
149	layer('a')
150	layer('b')
151
152	variant('browser') {
153	role('main') {
154	layers('a', 'b')
155	}
156	link('a', 'b', null)
157	}
158	}
159	""", "Link 'kind' must not be null or blank");
160	}
161
162	@Test
163	void failsOnDuplicatedLinkTuple() throws Exception {
164	assertBuildFails("""
165	plugins {
166	id 'org.implab.gradle-variants'
167	}
168
169	variants {
170	layer('a')
171	layer('b')
172
173	variant('browser') {
174	role('main') {
175	layers('a', 'b')
176	}
177	link('a', 'b', 'ts:api')
178	link('a', 'b', 'ts:api')
179	}
180	}
181	""", "has duplicated link tuple (from='a', to='b', kind='ts:api')");
182	}
183
184	@Test
185	void failsOnUnknownSourceLayerInLink() throws Exception {
186	assertBuildFails("""
187	plugins {
188	id 'org.implab.gradle-variants'
189	}
190
191	variants {
192	layer('a') {
193	}
194
195	variant('browser') {
196	role('main') {
197	layers('a')
198	}
199	link('missing', 'a', 'ts:api')
200	}
201	}
202	""", "references unknown source layer 'missing'");
203	}
204
205	@Test
206	void failsOnUnknownTargetLayerInLink() throws Exception {
207	assertBuildFails("""
208	plugins {
209	id 'org.implab.gradle-variants'
210	}
211
212	variants {
213	layer('a') {
214	}
215
216	variant('browser') {
217	role('main') {
218	layers('a')
219	}
220	link('a', 'missing', 'ts:api')
221	}
222	}
223	""", "references unknown target layer 'missing'");
224	}
225
226	@Test
227	void failsOnDuplicatedLayerReferenceInRole() throws Exception {	117	void failsOnDuplicatedLayerReferenceInRole() throws Exception {
228	assertBuildFails("""	118	assertBuildFails("""
229	plugins {	119	plugins {

common/variants-plugin.md +4 -22

                         layers('mainBase', 'mainAmd')
                     }
-                    link('mainBase', 'mainAmd', 'ts:api')
                     artifactSlot('mainCompiled')
                 }
             }
             ### layers
             Глобальные логические слои. Служат единым словарем имен, на которые затем
-            ссылаются роли и связи.
+            ссылаются роли.
             ### variants
             Именованные варианты исполнения/пакетирования (`browser`, `node`, и т.д.).
-            Вариант агрегирует роли, связи, атрибуты и artifact slots.
+            Вариант агрегирует роли, атрибуты и artifact slots.
             ### roles
             Роль описывает набор слоев в пределах варианта (`main`, `test`, `tools`).
             Одна роль может ссылаться на несколько слоев.
-            ### links
-            `link(from, to, kind)` — ориентированная связь между слоями внутри варианта.
-            `kind` задает независимый тип графа (например `ts:api`, `bundle:runtime`). Это
-            позволяет вести несколько параллельных графов зависимостей над теми же слоями.
-            Практические сценарии использования `link` в адаптерах:
-            - расчет topological order по выбранному `kind`;
-            - wiring task inputs/outputs между слоями;
-            - проверка допустимости дополнительных pipeline-зависимостей.
             ### attributes
             Typed-атрибуты (`Attribute<T> -> Provider<T>`) для передачи параметров в
             - роль не может ссылаться на неизвестный layer;
             - пустые имена layer запрещены;
-            - у link обязательны `from`, `to`, `kind`;
+            - имена ролей в варианте должны быть уникальны;
-            - `from`/`to` должны входить в слойную область варианта;
+            - имена artifact slots в варианте должны быть уникальны.
-            - tuple `(from, to, kind)` должен быть уникален;
-            - циклы в графе одного `kind` запрещены.
             ## LIFECYCLE
             - `attributes { ... }` — атрибуты варианта (+ sugar `string/bool/integer`).
             - `role(...)`, `roles { ... }` — роли варианта.
-            - `link(...)`, `links { ... }` — связи слоев внутри варианта.
             - `artifactSlot(...)`, `artifactSlots { ... }` — артефактные слоты.
             ## KEY CLASSES
             - `BuildVariant` — агрегатная модель варианта.
             - `BuildLayer` — модель слоя.
             - `BuildRole` — модель роли.
-            - `LayerLink` — модель направленной связи.
             - `BuildArtifactSlot` — модель артефактного слота.
             - `VariantAttributes` — typed wrapper для variant attributes.

common/src/main/java/org/implab/gradle/common/sources/LayerLink.java removed 0 -7

	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