implab/gradle-common Commit - r39:fdd8b56c7024

WIP Variants model

cin -

r39:fdd8b56c7024 default

parent child

Context file:

r39:fdd8b56c7024

Collapse all files

.vscode/settings.json +1 0

             {
                 "java.configuration.updateBuildConfiguration": "automatic",
                 "java.compile.nullAnalysis.mode": "automatic",
                 "cSpell.words": [
                     "implab",
+                    "materializer",
                     "rawtypes"
                 ]
             }

AGENTS.md +30 0

@@ -1,12 +1,42
1	# AGENTS.md	1	# AGENTS.md
2		2
3	## Проектные договоренности	3	## Проектные договоренности
4		4
5	### Публичное API библиотек	5	### Публичное API библиотек
6		6
7	- Предпочтителен `non-null` подход.	7	- Предпочтителен `non-null` подход.
8	- Там, где значение живет в Gradle Provider API, возвращается `Provider<T>` (не `null`).	8	- Там, где значение живет в Gradle Provider API, возвращается `Provider<T>` (не `null`).
9	- Там, где lookup синхронный, возвращается `Optional<T>` (не `null`).	9	- Там, где lookup синхронный, возвращается `Optional<T>` (не `null`).
10	- `find` рассматривается как синоним legacy `get` (поиск без `fail-fast`).	10	- `find` рассматривается как синоним legacy `get` (поиск без `fail-fast`).
11	- `require` это `find` + `fail-fast` с понятной ошибкой в месте вызова.	11	- `require` это `find` + `fail-fast` с понятной ошибкой в месте вызова.
12	- Для нового API предпочтительны формы `find/require`; новые `get*` по возможности не добавлять.	12	- Для нового API предпочтительны формы `find/require`; новые `get*` по возможности не добавлять.
		13
		14	## Identity-first modeling
		15
		16	Prefer an identity-first split between:
		17
		18	- identity objects used for discovery and selection
		19	- stateful/materialized objects obtained through separate API calls
		20
		21	### Rules
		22
		23	- Objects intended for replayable observation (`all(...)`, similar collection APIs) should be identity objects.
		24	- Identity objects must be:
		25	- cheap to create
		26	- effectively immutable
		27	- limited to identity and cheap selection metadata
		28	- Heavy, computed, provider-based, or runtime-bound state must be resolved separately.
		29	- Aggregate content should be accessed through dedicated lookup/materialization APIs.
		30	- Eager observation of identity is acceptable.
		31	- Eager observation of computed state is not.
		32
		33	### Do not
		34
		35	- Do not store heavy computed state inside identity objects.
		36	- Do not store runtime references to foreign domains inside identity objects.
		37	- Do not use custom events when replayable identity registries plus on-demand lookup are sufficient.
		38
		39	### Rule of thumb
		40
		41	**Identity objects contain selection metadata.
		42	Aggregate content is obtained separately, on demand.**

common/src/main/java/org/implab/gradle/common/core/lang/LazyValue.java +2 -1

             package org.implab.gradle.common.core.lang;
             import java.util.Objects;
             import java.util.function.Supplier;
             public class LazyValue<T> implements Supplier<T> {
                 private volatile T value;
+                private volatile boolean initialized = false;
                 private final Supplier<T> innerSupplier;
                 public LazyValue(Supplier<T> supplier) {
                     this.innerSupplier = supplier;
                 }
                 @Override
                 public T get() {
                     var v = value;
-                    if (v != null) {
+                    if (initialized) {
                         return v;
                     }
                     synchronized (this) {
                         v = value;
                         if (v == null) {
                             v = Objects.requireNonNull(
                                     innerSupplier.get(),
                                     "LazyValue supplier returned null");
                             value = v;
                         }
                         return v;
                     }
                 }
             }

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

             package org.implab.gradle.common.core.lang;
             import java.util.regex.Pattern;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.provider.Provider;
             @NonNullByDefault
             public class Strings {
                 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
                                     : firstLetter.matcher(string).replaceFirst(m -> m.group().toUpperCase());
                 }
                 public static String toCamelCase(String name) {
                     if (name == null || name.isEmpty())
                         return name;
                     StringBuilder out = new StringBuilder(name.length());
                     boolean up = false;
                     boolean first = true;
                     for (int i = 0; i < name.length(); i++) {
                         char c = name.charAt(i);
                         switch (c) {
                             case '-', '_', ' ', '.' -> up = true;
                             default -> {
                                 out.append(
                                         first ? Character.toLowerCase(c)
                                                 : up ? Character.toUpperCase(c): c);
                                 up = false;
                                 first = false;
                             }
                         }
                     }
                     return out.toString();
                 }
                 public static void argumentNotNullOrEmpty(String value, String argumentName) {
                     if (value == null || value.length() == 0)
                         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 requireNonBlank(String value) {
+                    argumentNotNullOrBlank(value, "value");
+                    return value;
+                }
                 public static String sanitizeName(String value) {
                     return INVALID_NAME_CHAR.matcher(value).replaceAll("_");
                 }
                 public static String asString(Object value) {
                     if (value == null)
                         return null;
                     if (value instanceof Provider<?> provider)
                         return asString(provider.get());
                     else
                         return value.toString();
                 }
             }

variants/src/main/java/org/implab/gradle/variants/VariantsPlugin.java +2 -4

             package org.implab.gradle.variants;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.implab.gradle.variants.model.VariantsExtension;
             public abstract class VariantsPlugin implements Plugin<Project> {
                 @Override
                 public void apply(Project target) {
-                    var extension = target.getExtensions().create("variants", VariantsExtension.class);
-                    target.afterEvaluate(project -> {
+                    target.getExtensions().create("variants", VariantsExtension.class);
-                    });
                 }
             }

variants/src/main/java/org/implab/gradle/variants/model/RoleLayerBinding.java ~~variants/src/main/java/org/implab/gradle/variants/model/RoleBinding.java~~ renamed +4 -31

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

variants/src/main/java/org/implab/gradle/variants/model/Variant.java 0 -32

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

variants/src/main/java/org/implab/gradle/variants/model/VariantsExtension.java +17 -11

             package org.implab.gradle.variants.model;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             /**
              * Root extension:
              *
              * variants {
-             *     layers { ... }
+             * layers { ... }
-             *     roles { ... }
+             * roles { ... }
              *
-             *     variant("browser") {
+             * variant("browser") {
-             *         role("production") {
+             * role("production") {
-             *             layers("main", "generated", "mainRjs")
+             * layers("main", "generated", "mainRjs")
-             *         }
+             * }
-             *     }
+             * }
              * }
              */
             public interface VariantsExtension {
                 /**
                  * Domain of layers.
                  */
                 NamedDomainObjectContainer<Layer> getLayers();
                 /**
                  * Domain of roles.
                  */
                 NamedDomainObjectContainer<Role> getRoles();
                 /**
+                 * Domain of variants.
+                 */
+                NamedDomainObjectContainer<Variant> getVariants();
+                /**
                  * Declared variants.
                  */
-                NamedDomainObjectContainer<Variant> getVariantDefinitions();
+                NamedDomainObjectContainer<VariantDefinition> getVariantDefinitions();
                 /**
                  * Creates or returns an existing variant and configures it.
                  */
-                default Variant variant(String name) {
+                default VariantDefinition variant(String name) {
                     return getVariantDefinitions().maybeCreate(name);
                 }
                 /**
                  * Creates or returns an existing variant and configures it.
                  */
-                default Variant variant(String name, Action<? super Variant> action) {
+                default VariantDefinition variant(String name, Action<? super VariantDefinition> action) {
                     var variant = variant(name);
                     action.execute(variant);
                     return variant;
                 }
-                default Variant variant(String name, Closure<?> closure) {
+                default VariantDefinition variant(String name, Closure<?> closure) {
                     return variant(name, Closures.action(closure));
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages