implab/gradle-common Commit - r54:3469331e3c4b

variants: enforce source configuration policies

cin -

r54:3469331e3c4b default

parent child

Context file:

r54:3469331e3c4b

Collapse all files

variants/src/main/java/org/implab/gradle/variants/VariantSourcesPlugin.java +3 -2

             package org.implab.gradle.variants;
             import java.util.Objects;
             import java.util.function.Predicate;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.common.core.lang.Strings;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsExtension;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.implab.gradle.variants.sources.CompileUnitsView;
             import org.implab.gradle.variants.sources.GenericSourceSet;
             import org.implab.gradle.variants.sources.RoleProjectionsView;
             import org.implab.gradle.variants.sources.VariantSourcesContext;
             import org.implab.gradle.variants.sources.VariantSourcesExtension;
             import org.implab.gradle.variants.sources.internal.CompileUnitNamer;
             import org.implab.gradle.variants.sources.internal.DefaultCompileUnitNamingPolicy;
             import org.implab.gradle.variants.sources.internal.DefaultLateConfigurationPolicySpec;
             import org.implab.gradle.variants.sources.internal.DefaultVariantSourcesContext;
             import org.implab.gradle.variants.sources.internal.SourceSetConfigurationRegistry;
             import org.implab.gradle.variants.sources.internal.SourceSetRegistry;
             @NonNullByDefault
             public abstract class VariantSourcesPlugin implements Plugin<Project> {
                 public static final String VARIANT_SOURCES_EXTENSION = "variantSources";
                 @Override
                 public void apply(Project target) {
                     var extensions = target.getExtensions();
                     // Apply the main VariantsPlugin to ensure the core variant model is available.
                     target.getPlugins().apply(VariantsPlugin.class);
                     // Access the VariantsExtension to configure variant sources.
                     var variantsExtension = extensions.getByType(VariantsExtension.class);
                     var objectFactory = target.getObjects();
                     var deferred = new Deferred<VariantSourcesContext>();
                     var lateConfigurationPolicy = new DefaultLateConfigurationPolicySpec();
                     var namingPolicy = new DefaultCompileUnitNamingPolicy();
                     variantsExtension.whenFinalized(variants -> {
                         // create variant views
                         var compileUnits = CompileUnitsView.of(variants);
                         var roleProjections = RoleProjectionsView.of(variants);
                         // create registries
                         var sourceSetRegistry = new SourceSetRegistry(objectFactory);
+                        lateConfigurationPolicy.finalizePolicy();
                         var sourceSetConfiguration = new SourceSetConfigurationRegistry(lateConfigurationPolicy::mode);
                         // build compile unit namer
                         var compileUnitNamer = CompileUnitNamer.builder()
                             .addUnits(compileUnits.getUnits())
                             .nameCollisionPolicy(namingPolicy.policy())
                             .build();
                         // create the context
                         var context = new DefaultVariantSourcesContext(
                             variants,
                             compileUnits,
                             roleProjections,
                             compileUnitNamer,
                             sourceSetRegistry,
                             sourceSetConfiguration
                         );
                         deferred.resolve(context);
                     });
                     var variantSourcesExtension = new VariantSourcesExtension() {
                         @Override
                         public void whenFinalized(Action<? super VariantSourcesContext> action) {
                             deferred.whenResolved(action::execute);
                         }
                         @Override
                         public void lateConfigurationPolicy(Action<? super LateConfigurationPolicySpec> action) {
                             action.execute(lateConfigurationPolicy);
                         }
                         @Override
                         public void namingPolicy(Action<? super NamingPolicySpec> action) {
                             action.execute(namingPolicy);
                         }
                         @Override
                         public void variant(String variantName, Action<? super GenericSourceSet> action) {
                             Strings.argumentNotNullOrBlank(variantName, "variantName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
                             whenFinalized(ctx -> ctx.configureVariant(resolveVariant(ctx.getVariants(), variantName), action));
                         }
                         @Override
                         public void layer(String layerName, Action<? super GenericSourceSet> action) {
                             // protect external DSL
                             Strings.argumentNotNullOrBlank(layerName, "layerName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
                             whenFinalized(ctx -> ctx.configureLayer(resolveLayer(ctx.getVariants(), layerName), action));
                         }
                         @Override
                         public void unit(String variantName, String layerName, Action<? super GenericSourceSet> action) {
                             Strings.argumentNotNullOrBlank(layerName, "layerName");
                             Strings.argumentNotNullOrBlank(variantName, "variantName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
                             whenFinalized(ctx -> ctx.configureUnit(resolveCompileUnit(ctx, variantName, layerName), action));
                         }
                     };
                     extensions.add(VariantSourcesExtension.class, VARIANT_SOURCES_EXTENSION, variantSourcesExtension);
                 }
                 private static Layer resolveLayer(VariantsView variants, String name) {
                     return variants.getLayers().stream()
                             .filter(named(name))
                             .findAny()
-                            .orElseThrow(() -> new IllegalArgumentException("Layer '" + name + "' isn't declared"));
+                            .orElseThrow(() -> new InvalidUserDataException("Layer '" + name + "' isn't declared"));
                 }
                 private static Variant resolveVariant(VariantsView variants, String name) {
                     return variants.getVariants().stream()
                             .filter(named(name))
                             .findAny()
-                            .orElseThrow(() -> new IllegalArgumentException("Variant '" + name + "' is't declared"));
+                            .orElseThrow(() -> new InvalidUserDataException("Variant '" + name + "' isn't declared"));
                 }
                 private static CompileUnit resolveCompileUnit(VariantSourcesContext ctx, String variantName, String layerName) {
                     return ctx.getCompileUnits().findUnit(
                             resolveVariant(ctx.getVariants(), variantName),
                             resolveLayer(ctx.getVariants(), layerName))
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "The CompileUnit isn't declared for variant '" + variantName + "', layer '" + layerName + "'"));
                 }
                 private static Predicate<Named> named(String name) {
                     return named -> named.getName().equals(name);
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesExtension.java +4 -1

             package org.implab.gradle.variants.sources;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             @NonNullByDefault
             public interface VariantSourcesExtension {
                 /**
                  * Selects how selector rules behave when they target an already materialized
                  * {@link GenericSourceSet}.
                  *
                  * <p>This policy is single-valued:
                  * <ul>
                  * <li>it must be selected before the first selector rule is registered via
                  * {@link #variant(String, Action)}, {@link #layer(String, Action)} or
                  * {@link #unit(String, String, Action)};</li>
-                 * <li>once selected, it cannot be changed later;</li>
+                 * <li>it must be selected before the finalized context becomes observable via
+                 * {@link #whenFinalized(Action)};</li>
+                 * <li>once selected or once the finalized context is being created, it cannot
+                 * be changed later;</li>
                  * <li>the policy controls both diagnostics and late-application semantics.</li>
                  * </ul>
                  *
                  * <p>If not selected explicitly, the default is
                  * {@link LateConfigurationPolicySpec#failOnLateConfiguration()}.
                  */
                 void lateConfigurationPolicy(Action<? super LateConfigurationPolicySpec> action);
                 default void lateConfigurationPolicy(Closure<?> closure) {
                     lateConfigurationPolicy(Closures.action(closure));
                 }
                 /**
                  * Selects how compile-unit name collisions are handled when the finalized
                  * source context is created.
                  *
                  * <p>This policy is single-valued:
                  * <ul>
                  * <li>it must be selected before the finalized
                  * {@link VariantSourcesContext} becomes observable through
                  * {@link #whenFinalized(Action)};</li>
                  * <li>once the context is being created, the policy is fixed and cannot be
                  * changed later;</li>
                  * <li>the policy governs validation of compile-unit names produced by the
                  * source-set materializer.</li>
                  * </ul>
                  *
                  * <p>If not selected explicitly, the default is
                  * {@link NamingPolicySpec#failOnNameCollision()}.
                  */
                 void namingPolicy(Action<? super NamingPolicySpec> action);
                 default void namingPolicy(Closure<?> closure) {
                     namingPolicy(Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for all compile units of the given layer.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
                 void layer(String layerName, Action<? super GenericSourceSet> action);
                 default void layer(String layerName, Closure<?> closure) {
                     layer(layerName, Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for all compile units of the given variant.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
                 void variant(String variantName, Action<? super GenericSourceSet> action);
                 default void variant(String variantName, Closure<?> closure) {
                     variant(variantName, Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for one exact compile unit.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
                 void unit(String variantName, String layerName, Action<? super GenericSourceSet> action);
                 default void unit(String variantName, String layerName, Closure<?> closure) {
                     unit(variantName, layerName, Closures.action(closure));
                 }
                 /**
                  * Invoked when finalized variants-derived source context becomes available.
                  *
                  * Replayable:
                  * <ul>
                  * <li>if called before variants finalization, action is queued
                  * <li>if called after variants finalization, action is invoked immediately
                  * </ul>
                  *
                  * <p>By the time this callback becomes observable, compile-unit naming
                  * policy has already been fixed and symbolic source-set names for finalized
                  * compile units are determined.
                  */
                 void whenFinalized(Action<? super VariantSourcesContext> action);
                 default void whenFinalized(Closure<?> closure) {
                     whenFinalized(Closures.action(closure));
                 }
                 /**
                  * Imperative selector for the late-configuration mode.
                  *
                  * <p>Exactly one mode is expected to be chosen for the extension lifecycle.
                  */
                 interface LateConfigurationPolicySpec {
                     /**
                      * Rejects selector registration if it targets any already materialized
                      * source set.
                      */
                     void failOnLateConfiguration();
                     /**
                      * Allows late selector registration, but emits a warning when it targets an
                      * already materialized source set.
                      *
                      * <p>For such targets, selector precedence is not re-established
                      * retroactively. The action is applied as a late imperative step, after the
                      * state already produced at the materialization moment.
                      */
                     void warnOnLateConfiguration();
                     /**
                      * Allows late selector registration without a warning when it targets an
                      * already materialized source set.
                      *
                      * <p>For such targets, selector precedence is not re-established
                      * retroactively. The action is applied as a late imperative step, after the
                      * state already produced at the materialization moment.
                      */
                     void allowLateConfiguration();
                 }
                 interface NamingPolicySpec {
                     /**
                      * Rejects finalized compile-unit models that project the same source-set
                      * name for different compile units.
                      */
                     void failOnNameCollision();
                     /**
                      * Resolves name collisions deterministically for the finalized
                      * compile-unit model.
                      *
                      * <p>Conflicting compile units are ordered canonically by
                      * {@code (variant.name, layer.name)}. The first unit keeps the base
                      * projected name, and each next unit receives a numeric suffix
                      * ({@code 2}, {@code 3}, ...).
                      */
                     void resolveNameCollision();
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/internal/DefaultLateConfigurationPolicySpec.java +1 0

             package org.implab.gradle.variants.sources.internal;
             import org.implab.gradle.variants.sources.VariantSourcesExtension.LateConfigurationPolicySpec;
             public class DefaultLateConfigurationPolicySpec implements LateConfigurationPolicySpec {
                 private LateConfigurationMode policyMode = LateConfigurationMode.FAIL;
                 private boolean policyApplied = false;
                 public LateConfigurationMode mode() {
+                    finalizePolicy();
                     return policyMode;
                 }
                 public void finalizePolicy() {
                     policyApplied = true;
                 }
                 @Override
                 public void failOnLateConfiguration() {
                     assertApplyOnce();
                     policyMode = LateConfigurationMode.FAIL;
                 }
                 @Override
                 public void warnOnLateConfiguration() {
                     assertApplyOnce();
                     policyMode = LateConfigurationMode.WARN;
                 }
                 @Override
                 public void allowLateConfiguration() {
                     assertApplyOnce();
                     policyMode = LateConfigurationMode.APPLY;
                 }
                 private void assertApplyOnce() {
                     if (policyApplied)
                         throw new IllegalStateException("Lazy configuration policy already applied");
                     policyApplied = true;
                 }
             }

variants/src/test/java/org/implab/gradle/variants/VariantSourcesPluginFunctionalTest.java +24 -1

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import org.gradle.testkit.runner.BuildResult;
             import org.junit.jupiter.api.Test;
             class VariantSourcesPluginFunctionalTest extends AbstractFunctionalTest {
                 @Test
                 void exposesDerivedViewsAndStableSourceSetProvider() throws Exception {
                     writeSettings("variant-sources-derived-views");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.roles.create('test')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                                 role('test') { layers('main', 'test') }
                             }
                             def lines = []
                             variantSources.whenFinalized { ctx ->
                                 lines << "units=" + ctx.compileUnits.units
                                     .collect { "${it.variant().name}:${it.layer().name}" }
                                     .sort()
                                     .join(',')
                                 def browser = ctx.variants.variants.find { it.name == 'browser' }
                                 def production = ctx.variants.roles.find { it.name == 'production' }
                                 def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                 def projection = ctx.roleProjections.requireProjection(browser, production)
                                 def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                 def left = ctx.sourceSets.getSourceSet(unit)
                                 def right = ctx.sourceSets.getSourceSet(unit)
                                 lines << "projectionUnits=" + ctx.roleProjections.getUnits(projection)
                                     .collect { it.layer().name }
                                     .sort()
                                     .join(',')
                                 lines << "mainSourceSet=" + left.name
                                 lines << "sameProvider=" + left.is(right)
                             }
                             afterEvaluate {
                                 variantSources.whenFinalized { ctx ->
                                     lines << "late:variants=" + ctx.variants.variants.collect { it.name }.sort().join(',')
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     lines.each { println(it) }
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("units=browser:main,browser:test"));
                     assertTrue(result.getOutput().contains("projectionUnits=main"));
                     assertTrue(result.getOutput().contains("mainSourceSet=browserMain"));
                     assertTrue(result.getOutput().contains("sameProvider=true"));
                     assertTrue(result.getOutput().contains("late:variants=browser"));
                 }
                 @Test
                 void appliesSelectorPrecedenceForFutureMaterialization() throws Exception {
                     writeSettings("variant-sources-precedence");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.roles.create('test')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                                 role('test') { layers('main', 'test') }
                             }
                             variantsExt.variant('node') {
                                 role('production') { layers('main') }
                             }
                             def events = []
                             variantSources {
                                 variant('browser') {
                                     events << "variant:" + name
                                 }
                                 layer('main') {
                                     events << "layer:" + name
                                 }
                                 unit('browser', 'main') {
                                     events << "unit:" + name
                                 }
                             }
                             afterEvaluate {
                                 variantSources.whenFinalized { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def node = ctx.variants.variants.find { it.name == 'node' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def testLayer = ctx.variants.layers.find { it.name == 'test' }
                                     def browserMain = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(browser, mainLayer)).get()
                                     def browserTest = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(browser, testLayer)).get()
                                     def nodeMain = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(node, mainLayer)).get()
                                     def bySourceSet = events.groupBy { it.split(':', 2)[1] }
                                     println("browserMain=" + bySourceSet[browserMain.name].collect { it.split(':', 2)[0] }.join(','))
                                     println("browserTest=" + bySourceSet[browserTest.name].collect { it.split(':', 2)[0] }.join(','))
                                     println("nodeMain=" + bySourceSet[nodeMain.name].collect { it.split(':', 2)[0] }.join(','))
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("browserMain=variant,layer,unit"));
                     assertTrue(result.getOutput().contains("browserTest=variant"));
                     assertTrue(result.getOutput().contains("nodeMain=layer"));
                 }
                 @Test
                 void failsLateConfigurationByDefaultAfterMaterialization() throws Exception {
                     writeSettings("variant-sources-late-fail");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             afterEvaluate {
                                 variantSources.whenFinalized { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                     ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
                                         declareOutputs('late')
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Source sets for [layer=main] layer already materialized", "help");
                 }
                 @Test
                 void allowsLateConfigurationWhenSelectedBeforeFirstSelector() throws Exception {
                     writeSettings("variant-sources-late-allow");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             afterEvaluate {
                                 variantSources.whenFinalized { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                     def sourceSet = ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
                                         declareOutputs('late')
                                     }
                                     sourceSet.output('late')
                                     println('lateAllowed=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("lateAllowed=ok"));
                 }
                 @Test
                 void warnsAndAppliesLateConfigurationWhenWarnModeSelected() throws Exception {
                     writeSettings("variant-sources-late-warn");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 lateConfigurationPolicy {
                                     warnOnLateConfiguration()
                                 }
                             }
                             afterEvaluate {
                                 variantSources.whenFinalized { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                     def sourceSet = ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
                                         declareOutputs('late')
                                     }
                                     sourceSet.output('late')
                                     println('lateWarn=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("Source sets for [layer=main] layer already materialized"));
                     assertTrue(result.getOutput().contains("lateWarn=ok"));
                 }
                 @Test
                 void rejectsChangingLateConfigurationPolicyAfterFirstSelector() throws Exception {
                     writeSettings("variant-sources-late-policy-fixed");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 variant('browser') {
                                     declareOutputs('js')
                                 }
                                 lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             """);
                     assertBuildFails("Lazy configuration policy already applied", "help");
                 }
                 @Test
                 void failsOnProjectedNameCollisionByDefault() throws Exception {
                     writeSettings("variant-sources-name-collision-fail");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('variantBar')
                             variantsExt.layers.create('bar')
                             variantsExt.roles.create('production')
                             variantsExt.variant('foo') {
                                 role('production') { layers('variantBar') }
                             }
                             variantsExt.variant('fooVariant') {
                                 role('production') { layers('bar') }
                             }
                             """);
                     assertBuildFails("The same source set names are produced by different compile units", "help");
                 }
                 @Test
                 void resolvesProjectedNameCollisionDeterministicallyWhenConfigured() throws Exception {
                     writeSettings("variant-sources-name-collision-resolve");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('variantBar')
                             variantsExt.layers.create('bar')
                             variantsExt.roles.create('production')
                             variantsExt.variant('foo') {
                                 role('production') { layers('variantBar') }
                             }
                             variantsExt.variant('fooVariant') {
                                 role('production') { layers('bar') }
                             }
                             variantSources {
                                 namingPolicy {
                                     resolveNameCollision()
                                 }
                             }
                             afterEvaluate {
                                 variantSources.whenFinalized { ctx ->
                                     def foo = ctx.variants.variants.find { it.name == 'foo' }
                                     def fooVariant = ctx.variants.variants.find { it.name == 'fooVariant' }
                                     def variantBar = ctx.variants.layers.find { it.name == 'variantBar' }
                                     def bar = ctx.variants.layers.find { it.name == 'bar' }
                                     def later = ctx.compileUnits.requireUnit(fooVariant, bar)
                                     def earlier = ctx.compileUnits.requireUnit(foo, variantBar)
                                     println("map1=" + later.variant().name + ":" + later.layer().name + "->" + ctx.sourceSets.getSourceSet(later).name)
                                     println("map2=" + earlier.variant().name + ":" + earlier.layer().name + "->" + ctx.sourceSets.getSourceSet(earlier).name)
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("map1=fooVariant:bar->fooVariantBar2"));
                     assertTrue(result.getOutput().contains("map2=foo:variantBar->fooVariantBar"));
                 }
                 @Test
                 void failsOnUnknownVariantSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-variant");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 variant('missing') {
                                     declareOutputs('js')
                                 }
                             }
                             """);
-                    assertBuildFails("Variant 'missing' is't declared", "help");
+                    assertBuildFails("Variant 'missing' isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownLayerSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-layer");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 layer('missing') {
                                     declareOutputs('js')
                                 }
                             }
                             """);
                     assertBuildFails("Layer 'missing' isn't declared", "help");
                 }
                 @Test
                 void failsOnUndeclaredCompileUnitSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-unit");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 unit('browser', 'test') {
                                     declareOutputs('js')
                                 }
                             }
                             """);
                     assertBuildFails("The CompileUnit isn't declared for variant 'browser', layer 'test'", "help");
                 }
                 @Test
                 void rejectsChangingNamingPolicyAfterContextBecomesObservable() throws Exception {
                     writeSettings("variant-sources-name-policy-fixed");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources.whenFinalized {
                                 variantSources.namingPolicy {
                                     resolveNameCollision()
                                 }
                             }
                             """);
                     assertBuildFails("Naming policy already applied", "help");
                 }
+                @Test
+                void rejectsChangingLateConfigurationPolicyAfterContextBecomesObservable() throws Exception {
+                    writeSettings("variant-sources-late-policy-context-fixed");
+                    writeBuildFile("""
+                            apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
+                            def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
+                            variantsExt.layers.create('main')
+                            variantsExt.roles.create('production')
+                            variantsExt.variant('browser') {
+                                role('production') { layers('main') }
+                            }
+                            variantSources.whenFinalized {
+                                variantSources.lateConfigurationPolicy {
+                                    allowLateConfiguration()
+                                }
+                            }
+                            """);
+                    assertBuildFails("Lazy configuration policy already applied", "help");
+                }
             }

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