implab/gradle-common Commit - r42:d67a4d2c04cf

WIP stable versions CompileUnitsView, RoleProjectionsView, VariantSourcesExtension

cin -

r42:d67a4d2c04cf default

parent child

Context file:

r42:d67a4d2c04cf

Collapse all files

variants/src/main/java/org/implab/gradle/variants/VariantSourcesPlugin.java +74 0

@@ -1,11 +1,20
1	package org.implab.gradle.variants;	1	package org.implab.gradle.variants;
2		2
3	import org.eclipse.jdt.annotation.NonNullByDefault;	3	import org.eclipse.jdt.annotation.NonNullByDefault;
		4	import org.gradle.api.Action;
4	import org.gradle.api.Plugin;	5	import org.gradle.api.Plugin;
5	import org.gradle.api.Project;	6	import org.gradle.api.Project;
6	import org.implab.gradle.common.core.lang.Deferred;	7	import org.implab.gradle.common.core.lang.Deferred;
		8	import org.implab.gradle.common.sources.GenericSourceSet;
7	import org.implab.gradle.common.sources.SourcesPlugin;	9	import org.implab.gradle.common.sources.SourcesPlugin;
		10	import org.implab.gradle.variants.core.Layer;
		11	import org.implab.gradle.variants.core.Variant;
8	import org.implab.gradle.variants.core.VariantsExtension;	12	import org.implab.gradle.variants.core.VariantsExtension;
		13	import org.implab.gradle.variants.core.VariantsView;
		14	import org.implab.gradle.variants.sources.CompileUnit;
		15	import org.implab.gradle.variants.sources.CompileUnitsView;
		16	import org.implab.gradle.variants.sources.RoleProjectionsView;
		17	import org.implab.gradle.variants.sources.SourceSetMaterializer;
9	import org.implab.gradle.variants.sources.VariantSourcesContext;	18	import org.implab.gradle.variants.sources.VariantSourcesContext;
10		19
11	@NonNullByDefault	20	@NonNullByDefault
@@ -23,6 +32,71 public abstract class VariantSourcesPlug
23		32
24	var deferred = new Deferred<VariantSourcesContext>();	33	var deferred = new Deferred<VariantSourcesContext>();
25		34
		35	variantsExtension.whenFinalized(variants -> {
		36	var compileUnits = CompileUnitsView.of(variants);
		37	var roleProjections = RoleProjectionsView.of(variants);
		38
		39	var context = new Context(variants, compileUnits, roleProjections);
		40
		41	deferred.resolve(context);
		42	});
		43
		44	// var
		45
26	}	46	}
27		47
		48	private static class Context implements VariantSourcesContext {
		49
		50	private final VariantsView variantsView;
		51	private final CompileUnitsView compileUnitsView;
		52	private final RoleProjectionsView roleProjectionsView;
		53
		54	Context(VariantsView variantsView, CompileUnitsView compileUnitsView, RoleProjectionsView roleProjectionsView) {
		55	this.variantsView = variantsView;
		56	this.compileUnitsView = compileUnitsView;
		57	this.roleProjectionsView = roleProjectionsView;
		58	}
		59
		60	@Override
		61	public VariantsView getVariants() {
		62	return variantsView;
		63	}
		64
		65	@Override
		66	public CompileUnitsView getCompileUnits() {
		67	return compileUnitsView;
		68	}
		69
		70	@Override
		71	public RoleProjectionsView getRoleProjections() {
		72	return roleProjectionsView;
		73	}
		74
		75	@Override
		76	public SourceSetMaterializer getSourceSets() {
		77	// TODO Auto-generated method stub
		78	throw new UnsupportedOperationException("Unimplemented method 'getSourceSets'");
		79	}
		80
		81	@Override
		82	public void configureLayer(Layer layer, Action<? super GenericSourceSet> action) {
		83	// TODO Auto-generated method stub
		84	throw new UnsupportedOperationException("Unimplemented method 'configureLayer'");
		85	}
		86
		87	@Override
		88	public void configureVariant(Variant variant, Action<? super GenericSourceSet> action) {
		89	// TODO Auto-generated method stub
		90	throw new UnsupportedOperationException("Unimplemented method 'configureVariant'");
		91	}
		92
		93	@Override
		94	public void configureUnit(CompileUnit unit, Action<? super GenericSourceSet> action) {
		95	// TODO Auto-generated method stub
		96	throw new UnsupportedOperationException("Unimplemented method 'configureUnit'");
		97	}
		98
		99	}
		100
		101
28	}	102	}

variants/src/main/java/org/implab/gradle/variants/sources/CompileUnit.java ~~variants/src/main/java/org/implab/gradle/variants/derived/CompileUnit.java~~ renamed +6 -1

-            package org.implab.gradle.variants.derived;
+            package org.implab.gradle.variants.sources;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
+            import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
             public record CompileUnit(Variant variant, Layer layer) {
+                public static CompileUnit of(VariantRoleLayer entry) {
+                    return new CompileUnit(entry.variant(), entry.layer());
+                }
             }

variants/src/main/java/org/implab/gradle/variants/sources/CompileUnitsView.java ~~variants/src/main/java/org/implab/gradle/variants/derived/CompileUnitsView.java~~ renamed +58 -12

@@ -1,32 +1,78
1	package org.implab.gradle.variants.~~derived~~;	1	package org.implab.gradle.variants.sources;
2		2
		3	import java.util.HashMap;
		4	import java.util.Map;
		5	import java.util.Objects;
3	import java.util.Optional;	6	import java.util.Optional;
4	import java.util.Set;	7	import java.util.Set;
		8	import java.util.stream.Collectors;
5		9
6	import org.eclipse.jdt.annotation.NonNullByDefault;	10	import org.eclipse.jdt.annotation.NonNullByDefault;
7	import org.implab.gradle.variants.core.Layer;	11	import org.implab.gradle.variants.core.Layer;
8	import org.implab.gradle.variants.core.Role;	12	import org.implab.gradle.variants.core.Role;
9	import org.implab.gradle.variants.core.Variant;	13	import org.implab.gradle.variants.core.Variant;
		14	import org.implab.gradle.variants.core.VariantsView;
		15	import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
10		16
11	@NonNullByDefault	17	@NonNullByDefault
12	public ~~interface~~ CompileUnitsView {	18	public final class CompileUnitsView {
13	Set<CompileUnit> getUnits();	19
		20	private final VariantsView variants;
		21	private final Map<Variant, Set<CompileUnit>> unitsByVariant = new HashMap<>();
		22
		23	private CompileUnitsView(VariantsView variants) {
		24	this.variants = variants;
		25	}
		26
		27	public Set<CompileUnit> getUnits() {
		28	return variants.getEntries().stream()
		29	.map(CompileUnit::of)
		30	.collect(Collectors.toUnmodifiableSet());
		31	}
		32
		33	public Set<CompileUnit> getUnitsForVariant(Variant variant) {
		34	Objects.requireNonNull(variant, "Variant can't be null");
		35
		36	return unitsByVariant.computeIfAbsent(variant, key -> variants
		37	.getEntriesForVariant(variant).stream()
		38	.map(CompileUnit::of)
		39	.collect(Collectors.toUnmodifiableSet()));
		40	}
14		41
15	~~Set~~<CompileUnit> ~~getUnitsForVarian~~t(Variant variant);	42	public Optional<CompileUnit> findUnit(Variant variant, Layer layer) {
		43	Objects.requireNonNull(variant, "Variant can't be null");
		44	Objects.requireNonNull(layer, "Layer can't be null");
		45
		46	return getUnitsForVariant(variant).stream()
		47	.filter(u -> u.layer().equals(layer))
		48	.findAny();
		49	}
		50
		51	public boolean contains(Variant variant, Layer layer) {
		52	return findUnit(variant, layer).isPresent();
		53	}
16		54
17	Optional<CompileUnit> findUnit(Variant variant, Layer layer);	55	/**
		56	* In which logical roles this compile unit participates.
		57	*/
18		58
19	default CompileUnit getUnit(Variant variant, Layer layer) {	59	public Set<Role> getRoles(CompileUnit unit) {
		60	Objects.requireNonNull(unit, "Compile unit can't be null");
		61	return variants.getEntriesForVariant(unit.variant()).stream()
		62	.filter(entry -> entry.layer().equals(unit.layer()))
		63	.map(VariantRoleLayer::role)
		64	.collect(Collectors.toUnmodifiableSet());
		65	}
		66
		67	public CompileUnit getUnit(Variant variant, Layer layer) {
20	return findUnit(variant, layer)	68	return findUnit(variant, layer)
21	.orElseThrow(() -> new IllegalArgumentException(	69	.orElseThrow(() -> new IllegalArgumentException(
22	"Compile unit for variant '" + variant.getName()	70	"Compile unit for variant '" + variant.getName()
23	+ "' and layer '" + layer.getName() + "' not found"));	71	+ "' and layer '" + layer.getName() + "' not found"));
24	}	72	}
25		73
26	boolean contains(Variant variant, Layer layer);	74	public static CompileUnitsView of(VariantsView variantsView) {
27		75	Objects.requireNonNull(variantsView, "variantsView can't be null");
28	/**	76	return new CompileUnitsView(variantsView);
29	* In which logical roles this compile unit participates.	77	}
30	*/
31	Set<Role> getRoles(CompileUnit unit);
32	} No newline at end of file	78	}

variants/src/main/java/org/implab/gradle/variants/sources/RoleProjection.java ~~variants/src/main/java/org/implab/gradle/variants/derived/RoleProjection.java~~ renamed +6 -1

-            package org.implab.gradle.variants.derived;
+            package org.implab.gradle.variants.sources;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
+            import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
             public record RoleProjection(Variant variant, Role role) {
+                public static RoleProjection of(VariantRoleLayer entry) {
+                    return new RoleProjection(entry.variant(), entry.role());
+                }
             }

variants/src/main/java/org/implab/gradle/variants/sources/RoleProjectionsView.java ~~variants/src/main/java/org/implab/gradle/variants/derived/RoleProjectionsView.java~~ renamed +60 -12

@@ -1,35 +1,83
1	package org.implab.gradle.variants.~~derived~~;	1	package org.implab.gradle.variants.sources;
2		2
		3	import java.util.HashMap;
		4	import java.util.Map;
		5	import java.util.Objects;
3	import java.util.Optional;	6	import java.util.Optional;
4	import java.util.Set;	7	import java.util.Set;
		8	import java.util.stream.Collectors;
5		9
6	import org.implab.gradle.variants.core.Layer;	10	import org.implab.gradle.variants.core.Layer;
7	import org.implab.gradle.variants.core.Role;	11	import org.implab.gradle.variants.core.Role;
8	import org.implab.gradle.variants.core.Variant;	12	import org.implab.gradle.variants.core.Variant;
		13	import org.implab.gradle.variants.core.VariantsView;
9		14
10	public ~~interface~~ RoleProjectionsView {	15	public final class RoleProjectionsView {
11	Set<RoleProjection> getProjections();	16	private final VariantsView variants;
		17
		18	private final Map<Variant, Set<RoleProjection>> projectionsByVariant = new HashMap<>();
		19
		20	private RoleProjectionsView(VariantsView variants) {
		21	this.variants = variants;
		22	}
12		23
13	Set<RoleProjection> getProjections~~ForVariant~~(~~Variant~~ ~~variant~~);	24	public Set<RoleProjection> getProjections() {
		25	return variants.getEntries().stream()
		26	.map(RoleProjection::of)
		27	.collect(Collectors.toUnmodifiableSet());
		28	}
		29
		30	public Set<RoleProjection> getProjectionsForVariant(Variant variant) {
		31	Objects.requireNonNull(variant, "Variant can't be null");
		32	return projectionsByVariant.computeIfAbsent(variant, key -> variants
		33	.getEntriesForVariant(variant).stream()
		34	.map(RoleProjection::of)
		35	.collect(Collectors.toUnmodifiableSet()));
		36	}
14		37
15	Set<RoleProjection> getProjectionsForRole(Role role);	38	public Set<RoleProjection> getProjectionsForRole(Role role) {
		39	Objects.requireNonNull(role, "Role can't be null");
		40	return variants.getEntriesForRole(role).stream()
		41	.map(RoleProjection::of)
		42	.collect(Collectors.toUnmodifiableSet());
		43	}
16		44
17	Optional<RoleProjection> findProjection(Variant variant, Role role);	45	public Optional<RoleProjection> findProjection(Variant variant, Role role) {
		46	Objects.requireNonNull(variant, "Variant can't be null");
		47	Objects.requireNonNull(role, "Role can't be null");
		48	return variants.getEntriesForVariant(variant).stream()
		49	.filter(entry -> entry.role().equals(role))
		50	.map(RoleProjection::of)
		51	.findAny();
		52	}
18		53
19	~~default~~ ~~RoleProjectio~~n ~~getProjection~~(Variant variant, Role role) {	54	public boolean contains(Variant variant, Role role) {
		55	return findProjection(variant, role).isPresent();
		56	}
		57
		58	public Set<CompileUnit> getUnits(RoleProjection projection) {
		59	Objects.requireNonNull(projection, "Role projection can't be null");
		60	return variants.getEntriesForVariant(projection.variant()).stream()
		61	.filter(entry -> entry.role().equals(projection.role()))
		62	.map(CompileUnit::of)
		63	.collect(Collectors.toUnmodifiableSet());
		64
		65	}
		66
		67	public RoleProjection getProjection(Variant variant, Role role) {
20	return findProjection(variant, role)	68	return findProjection(variant, role)
21	.orElseThrow(() -> new IllegalArgumentException(	69	.orElseThrow(() -> new IllegalArgumentException(
22	"Role projection for variant '" + variant.getName()	70	"Role projection for variant '" + variant.getName()
23	+ "' and role '" + role.getName() + "' not found"));	71	+ "' and role '" + role.getName() + "' not found"));
24	}	72	}
25		73
26	boolean contains(Variant variant, Role role);	74	public Set<Layer> getLayers(RoleProjection projection) {
27
28	Set<CompileUnit> getUnits(RoleProjection projection);
29
30	default Set<Layer> getLayers(RoleProjection projection) {
31	return getUnits(projection).stream()	75	return getUnits(projection).stream()
32	.map(CompileUnit::layer)	76	.map(CompileUnit::layer)
33	.collect(java.util.stream.Collectors.toUnmodifiableSet());	77	.collect(java.util.stream.Collectors.toUnmodifiableSet());
34	}	78	}
		79
		80	public static RoleProjectionsView of(VariantsView variantsView) {
		81	return new RoleProjectionsView(variantsView);
		82	}
35	} No newline at end of file	83	}

variants/src/main/java/org/implab/gradle/variants/sources/SourceSetMaterializer.java 0 -1

             import org.gradle.api.NamedDomainObjectProvider;
             import org.implab.gradle.common.sources.GenericSourceSet;
-            import org.implab.gradle.variants.derived.CompileUnit;
             /**
              * Materializes symbolic source set names into actual GenericSourceSet

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesContext.java +6 -5

             package org.implab.gradle.variants.sources;
-            import java.util.Set;
             import org.gradle.api.Action;
-            import org.gradle.api.NamedDomainObjectCollection;
             import org.implab.gradle.common.sources.GenericSourceSet;
             import org.implab.gradle.variants.core.Layer;
+            import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
-            import org.implab.gradle.variants.derived.CompileUnitsView;
-            import org.implab.gradle.variants.derived.RoleProjectionsView;
             /**
              * Registry of symbolic source set names produced by sources projection.
                  * Actions are applied in registration order.
                  */
                 void configureLayer(Layer layer, Action<? super GenericSourceSet> action);
+                void configureVariant(Variant variant, Action<? super GenericSourceSet> action);
+                void configureUnit(CompileUnit unit, Action<? super GenericSourceSet> action);
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesExtension.java +73 -2

@@ -1,22 +1,93
1	package org.implab.gradle.variants.sources;	1	package org.implab.gradle.variants.sources;
2		2
		3	import java.util.Objects;
		4	import java.util.function.Predicate;
		5
		6	import org.eclipse.jdt.annotation.NonNullByDefault;
3	import org.gradle.api.Action;	7	import org.gradle.api.Action;
		8	import org.gradle.api.InvalidUserDataException;
		9	import org.gradle.api.Named;
4	import org.implab.gradle.common.core.lang.Closures;	10	import org.implab.gradle.common.core.lang.Closures;
		11	import org.implab.gradle.common.core.lang.Strings;
		12	import org.implab.gradle.common.sources.GenericSourceSet;
		13	import org.implab.gradle.variants.core.Layer;
		14	import org.implab.gradle.variants.core.Variant;
		15	import org.implab.gradle.variants.core.VariantsView;
5		16
6	import groovy.lang.Closure;	17	import groovy.lang.Closure;
7		18
		19	@NonNullByDefault
8	public interface VariantSourcesExtension {	20	public interface VariantSourcesExtension {
9		21
		22	default void layer(String layerName, Action<? super GenericSourceSet> action) {
		23	// protect external DSL
		24	Strings.argumentNotNullOrBlank(layerName, "layerName");
		25	Objects.requireNonNull(action, "action can't be null");
		26
		27	whenFinalized(ctx -> ctx.configureLayer(resolveLayer(ctx.getVariants(), layerName), action));
		28	}
		29
		30	default void layer(String layerName, Closure<?> closure) {
		31	layer(layerName, Closures.action(closure));
		32	}
		33
		34	default void variant(String variantName, Action<? super GenericSourceSet> action) {
		35	Strings.argumentNotNullOrBlank(variantName, "variantName");
		36	Objects.requireNonNull(action, "action can't be null");
		37
		38	whenFinalized(ctx -> ctx.configureVariant(resolveVariant(ctx.getVariants(), variantName), action));
		39	}
		40
		41	default void variant(String variantName, Closure<?> closure) {
		42	variant(variantName, Closures.action(closure));
		43	}
		44
		45	default void unit(String variantName, String layerName, Action<? super GenericSourceSet> action) {
		46	Strings.argumentNotNullOrBlank(layerName, "layerName");
		47	Strings.argumentNotNullOrBlank(variantName, "variantName");
		48	Objects.requireNonNull(action, "action can't be null");
		49
		50	whenFinalized(ctx -> ctx.configureUnit(resolveCompileUnit(ctx, variantName, layerName), action));
		51	}
		52
10	/**	53	/**
11	* Invoked when finalized variants-derived source context becomes available.	54	* Invoked when finalized variants-derived source context becomes available.
12	*	55	*
13	* Replayable:	56	* Replayable:
14	* - if called before variants finalization, action is queued	57	* <ul>
15	* ~~- if called after~~ variants finalization, action is ~~invoked immediately~~	58	* <li>if called before variants finalization, action is queued
		59	* <li>if called after variants finalization, action is invoked immediately
		60	* </ul>
16	*/	61	*/
17	void whenFinalized(Action<? super VariantSourcesContext> action);	62	void whenFinalized(Action<? super VariantSourcesContext> action);
18		63
19	default void whenFinalized(Closure<?> closure) {	64	default void whenFinalized(Closure<?> closure) {
20	whenFinalized(Closures.action(closure));	65	whenFinalized(Closures.action(closure));
21	}	66	}
		67
		68	private static Layer resolveLayer(VariantsView variants, String name) {
		69	return variants.getLayers().stream()
		70	.filter(named(name))
		71	.findAny()
		72	.orElseThrow(() -> new IllegalArgumentException("Layer '" + name + "' isn't declared"));
		73	}
		74
		75	private static Variant resolveVariant(VariantsView variants, String name) {
		76	return variants.getVariants().stream()
		77	.filter(named(name))
		78	.findAny()
		79	.orElseThrow(() -> new IllegalArgumentException("Variant '" + name + "' is't declared"));
		80	}
		81
		82	private static CompileUnit resolveCompileUnit(VariantSourcesContext ctx, String variantName, String layerName) {
		83	return ctx.getCompileUnits().findUnit(
		84	resolveVariant(ctx.getVariants(), variantName),
		85	resolveLayer(ctx.getVariants(), layerName))
		86	.orElseThrow(() -> new InvalidUserDataException(
		87	"The CompileUnit isn't declared for variant '" + variantName + "', layer '" + layerName + "'"));
		88	}
		89
		90	private static Predicate<Named> named(String name) {
		91	return named -> named.getName().equals(name);
		92	}
22	} No newline at end of file	93	}

variants/src/main/java/org/implab/gradle/variants/sources/internal/DefaultLayerConfigurationRegistry.java +15 -6

             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.Map;
-            import java.util.Objects;
+            import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.implab.gradle.common.sources.GenericSourceSet;
             import org.implab.gradle.variants.core.Layer;
-            import org.implab.gradle.variants.derived.CompileUnit;
+            import org.implab.gradle.variants.core.Variant;
+            import org.implab.gradle.variants.sources.CompileUnit;
+            @NonNullByDefault
             public class DefaultLayerConfigurationRegistry implements LayerConfigurationRegistry {
                 private final Map<Layer, List<Action<? super GenericSourceSet>>> actionsByLayer = new LinkedHashMap<>();
+                private final Map<Variant, List<Action<? super GenericSourceSet>>> actionsByVariant = new LinkedHashMap<>();
+                private final Map<CompileUnit, List<Action<? super GenericSourceSet>>> actionsByUnit = new LinkedHashMap<>();
-                @Override
+                public void addLayerAction(Layer layer, Action<? super GenericSourceSet> action) {
-                public void add(Layer layer, Action<? super GenericSourceSet> action) {
-                    Objects.requireNonNull(layer, "layer can't be null");
-                    Objects.requireNonNull(action, "action can't be null");
                     actionsByLayer.computeIfAbsent(layer, key -> new ArrayList<>()).add(action);
                 }
+                public void addVariantAction(Variant variant, Action<? super GenericSourceSet> action) {
+                    actionsByVariant.computeIfAbsent(variant, key -> new ArrayList<>()).add(action);
+                }
+                public void addUnitAction(CompileUnit unit, Action<? super GenericSourceSet> action) {
+                    actionsByUnit.computeIfAbsent(unit, key -> new ArrayList<>()).add(action);
+                }
                 @Override
                 public void applyLayer(Layer layer, GenericSourceSet sourceSet) {
                     var actions = actionsByLayer.get(layer);

variants/src/main/java/org/implab/gradle/variants/sources/internal/LayerConfigurationRegistry.java +2 -2

             import org.gradle.api.Action;
             import org.implab.gradle.common.sources.GenericSourceSet;
             import org.implab.gradle.variants.core.Layer;
-            import org.implab.gradle.variants.derived.CompileUnit;
+            import org.implab.gradle.variants.sources.CompileUnit;
             public interface LayerConfigurationRegistry {
-                void add(Layer layer, Action<? super GenericSourceSet> action);
+                void addLayerAction(Layer layer, Action<? super GenericSourceSet> action);
                 void applyLayer(Layer layer, GenericSourceSet sourceSet);

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