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` задает структуру пространства сборки: какие есть слои, какие роли
-             используют эти слои в каждом варианте, какие направленные связи между слоями
-             существуют. Модель не создает задачи и не привязана к TS/JS.
+             используют эти слои в каждом варианте, какие есть атрибуты и artifact slots.
+             Модель не создает задачи и не привязана к 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

              import java.util.ArrayList;
              import java.util.Collection;
              import java.util.Collections;
-             import java.util.HashMap;
-             import java.util.HashSet;
              import java.util.LinkedHashMap;
              import java.util.LinkedHashSet;
              import java.util.List;
              import java.util.Map;
              import java.util.Optional;
-             import java.util.Set;
              import javax.inject.Inject;
                      }
                      validateRoleAndArtifactNames(variant, errors);
-                     var variantLayers = validateRoleMappings(variant, layersByName, errors);
-                     validateLinks(variant, variantLayers, errors);
+                     validateRoleMappings(variant, layersByName, errors);
                  }
                  private static void validateRoleAndArtifactNames(BuildVariant variant, List<String> errors) {
                      }
                  }
-                 private static Set<String> validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,
+                 private static void validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,
                          List<String> errors) {
-                     var variantLayers = new LinkedHashSet<String>();
                      for (var role : variant.getRoles()) {
                          var seenLayers = new LinkedHashSet<String>();
                          for (var layerName : role.getLayers().getOrElse(List.of())) {
                              if (!seenLayers.add(normalizedLayerName)) {
                                  errors.add("Variant '" + variant.getName() + "', role '" + role.getName()
                                          + "' contains duplicated layer reference '" + normalizedLayerName + "'");
-                                 continue;
+                             }
-                             variantLayers.add(normalizedLayerName);
+                         }
+                     }
-                     return variantLayers;
+                 }
-                 private static void validateLinks(BuildVariant variant, Set<String> variantLayers, List<String> errors) {
-                     var seenLinks = new HashSet<String>();
-                     var edgesByKind = new HashMap<String, Map<String, Set<String>>>();
-                     for (var link : variant.getLinks()) {
-                         var from = normalize(link.from());
-                         var to = normalize(link.to());
-                         var kind = normalize(link.kind());
-                         if (from == null || to == null || kind == null) {
-                             errors.add("Variant '" + variant.getName() + "' has incomplete link (from/to/kind are required)");
-                             continue;
+                         }
-                         if (!variantLayers.contains(from)) {
-                             errors.add("Variant '" + variant.getName() + "' link references unknown source layer '"
-                                     + from + "'");
-                             continue;
+                         }
-                         if (!variantLayers.contains(to)) {
-                             errors.add("Variant '" + variant.getName() + "' link references unknown target layer '"
-                                     + to + "'");
-                             continue;
+                         }
-                         var linkKey = from + "\u0000" + to + "\u0000" + kind;
-                         if (!seenLinks.add(linkKey)) {
-                             errors.add("Variant '" + variant.getName() + "' has duplicated link tuple (from='" + from
-                                     + "', to='" + to + "', kind='" + kind + "')");
+                         }
-                         edgesByKind
-                                 .computeIfAbsent(kind, x -> new LinkedHashMap<>())
-                                 .computeIfAbsent(from, x -> new LinkedHashSet<>())
-                                 .add(to);
+                     }
-                     for (var entry : edgesByKind.entrySet()) {
-                         if (hasCycle(variantLayers, entry.getValue())) {
-                             errors.add("Variant '" + variant.getName() + "' contains cycle in links with kind '" + entry.getKey() + "'");
                          }
                      }
                  }
-                 private static boolean hasCycle(Set<String> nodes, Map<String, Set<String>> edges) {
-                     var state = new HashMap<String, Integer>();
-                     for (var node : nodes) {
-                         if (dfs(node, state, edges))
-                             return true;
+                     }
-                     return false;
+                 }
-                 private static boolean dfs(String node, Map<String, Integer> state, Map<String, Set<String>> edges) {
-                     var current = state.getOrDefault(node, 0);
-                     if (current == 1)
-                         return true;
-                     if (current == 2)
-                         return false;
-                     state.put(node, 1);
-                     for (var next : edges.getOrDefault(node, Set.of())) {
-                         if (dfs(next, state, edges))
-                             return true;
+                     }
-                     state.put(node, 2);
-                     return false;
                  }
                  private static String normalize(String value) {
                      return trimmed.isEmpty() ? null : trimmed;
                  }
-                 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/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 "variantCap" -> Strings.capitalize(sanitize(usage.variantName()));
-                         case "role" -> sanitize(usage.roleName());
-                         case "roleCap" -> Strings.capitalize(sanitize(usage.roleName()));
-                         case "layer" -> sanitize(usage.layerName());
-                         case "layerCap" -> Strings.capitalize(sanitize(usage.layerName()));
+                         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 sanitize(String value) {
-                     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) {
+                 private static String normalize(@Nullable 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	48	role('main') {
49	49	layers('mainBase', 'mainAmd')
50	50	}
51		link('mainBase', 'mainAmd', 'ts:api')
52	51	artifactSlot('mainCompiled')
53	52	}
54	53	}
		@@ -58,7 +57,6 class VariantsPluginFunctionalTest {
58	57	def browser = variants.require('browser')
59	58	println('attributes=' + browser.attributes.size())
60	59	println('roles=' + browser.roles.size())
61		println('links=' + browser.links.size())
62	60	println('slots=' + browser.artifactSlots.size())
63	61	}
64	62	}
		@@ -68,7 +66,6 class VariantsPluginFunctionalTest {
68	66
69	67	assertTrue(result.getOutput().contains("attributes=2"));
70	68	assertTrue(result.getOutput().contains("roles=1"));
71		assertTrue(result.getOutput().contains("links=1"));
72	69	assertTrue(result.getOutput().contains("slots=1"));
73	70	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
74	71	}
		@@ -94,28 +91,6 class VariantsPluginFunctionalTest {
94	91	}
95	92
96	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	94	void allowsUsingLayerFromDifferentVariantRole() throws Exception {
120	95	writeFile(SETTINGS_FILE, ROOT_NAME);
121	96	writeFile(BUILD_FILE, """
		@@ -139,91 +114,6 class VariantsPluginFunctionalTest {
139	114	}
140	115
141	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	117	void failsOnDuplicatedLayerReferenceInRole() throws Exception {
228	118	assertBuildFails("""
229	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` должны входить в слойную область варианта;
-             - tuple `(from, to, kind)` должен быть уникален;
-             - циклы в графе одного `kind` запрещены.
+             - имена ролей в варианте должны быть уникальны;
+             - имена artifact slots в варианте должны быть уникальны.
              ## 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