implab/gradle-common Commit - r57:1abf7dba60ee

variants: validate source context identities

cin -

r57:1abf7dba60ee default

parent child

Context file:

r57:1abf7dba60ee

Collapse all files

variants/src/main/java/org/implab/gradle/variants/core/VariantsView.java +32 0

             package org.implab.gradle.variants.core;
             import java.util.ArrayList;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Optional;
             import java.util.Set;
             import java.util.stream.Collectors;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.InvalidUserDataException;
             /**
              * A resolved view of declared variants, roles, layers, and their bindings.
              *
              * Built from {@link VariantDefinition} instances, this class materializes validated
              * {@link VariantRoleLayer} entries and provides lookup APIs grouped by variant,
              * role, or layer.
              *
              * Typical usage is to collect identities and variant definitions through
              * {@link Builder}, then use the resulting view to traverse resolved bindings.
              */
             @NonNullByDefault
             public class VariantsView {
                 private final Set<Layer> layers;
                 private final Set<Role> roles;
                 private final Set<Variant> variants;
                 private final Set<VariantRoleLayer> entries;
                 private final Map<Variant, Set<VariantRoleLayer>> entriesByVariant;
                 private final Map<Role, Set<VariantRoleLayer>> entriesByRole;
                 private final Map<Layer, Set<VariantRoleLayer>> entriesByLayer;
                 private VariantsView(Set<Layer> layers, Set<Role> roles, Set<Variant> variants, Set<VariantRoleLayer> entries) {
                     this.layers = layers;
                     this.roles = roles;
                     this.variants = variants;
                     this.entries = entries;
                     this.entriesByVariant = entries.stream()
                             .collect(Collectors.groupingBy(VariantRoleLayer::variant, Collectors.toSet()));
                     this.entriesByRole = entries.stream()
                             .collect(Collectors.groupingBy(VariantRoleLayer::role, Collectors.toSet()));
                     this.entriesByLayer = entries.stream()
                             .collect(Collectors.groupingBy(VariantRoleLayer::layer, Collectors.toSet()));
                 }
                 /**
                  * Returns all declared layers included in this view.
                  */
                 public Set<Layer> getLayers() {
                     return layers;
                 }
                 /**
                  * Returns all declared roles included in this view.
                  */
                 public Set<Role> getRoles() {
                     return roles;
                 }
+                /**
+                 * Requires the layer to be declared in this view.
+                 *
+                 * @param layer layer identity
+                 * @throws InvalidUserDataException if the layer is not declared
+                 */
+                public void assertLayer(Layer layer) {
+                    Objects.requireNonNull(layer, "The layer can't be null");
+                    if (!layers.contains(layer))
+                        throw new InvalidUserDataException("The specified layer '" + layer.getName() + "' isn't declared");
+                }
+                /**
+                 * Requires the role to be declared in this view.
+                 *
+                 * @param role role identity
+                 * @throws InvalidUserDataException if the role is not declared
+                 */
                 public void assertRole(Role role) {
                     Objects.requireNonNull(role, "The role can't be null");
                     if (!roles.contains(role))
                         throw new InvalidUserDataException("The specified role '" + role.getName() + "' isn't declared");
                 }
                 /**
                  * Returns all declared variants included in this view.
                  */
                 public Set<Variant> getVariants() {
                     return variants;
                 }
                 /**
+                 * Requires the variant to be declared in this view.
+                 *
+                 * @param variant variant identity
+                 * @throws InvalidUserDataException if the variant is not declared
+                 */
+                public void assertVariant(Variant variant) {
+                    Objects.requireNonNull(variant, "The variant can't be null");
+                    if (!variants.contains(variant))
+                        throw new InvalidUserDataException("The specified variant '" + variant.getName() + "' isn't declared");
+                }
+                /**
                  * Returns all resolved variant-role-layer bindings.
                  */
                 public Set<VariantRoleLayer> getEntries() {
                     return entries;
                 }
                 /**
                  * Returns all bindings associated with the specified variant.
                  *
                  * An empty set is returned when the variant has no bindings in this view.
                  */
                 public Set<VariantRoleLayer> getEntriesForVariant(Variant variant) {
                     return entriesByVariant.getOrDefault(variant, Set.of());
                 }
                 /**
                  * Returns all bindings associated with the specified layer.
                  *
                  * An empty set is returned when the layer has no bindings in this view.
                  */
                 public Set<VariantRoleLayer> getEntriesForLayer(Layer layer) {
                     return entriesByLayer.getOrDefault(layer, Set.of());
                 }
                 /**
                  * Returns all bindings associated with the specified role.
                  *
                  * An empty set is returned when the role has no bindings in this view.
                  */
                 public Set<VariantRoleLayer> getEntriesForRole(Role role) {
                     return entriesByRole.getOrDefault(role, Set.of());
                 }
                 /**
                  * A resolved binding between a variant, a role, and a layer.
                  *
                  * @param variant the resolved variant
                  * @param role the resolved role
                  * @param layer the resolved layer
                  */
                 public record VariantRoleLayer(Variant variant, Role role, Layer layer) {
                 }
                 /**
                  * Creates a builder for assembling a {@link VariantsView}.
                  */
                 public static Builder builder() {
                     return new Builder();
                 }
                 /**
                  * Collects declared identities and variant definitions, then resolves them
                  * into a {@link VariantsView}.
                  */
                 public static class Builder {
                     private final Map<String, Layer> layers = new LinkedHashMap<>();
                     private final Map<String, Role> roles = new LinkedHashMap<>();
                     private final Map<String, Variant> variants = new LinkedHashMap<>();
                     private final List<VariantDefinition> definitions = new ArrayList<>();
                     private Builder() {
                     }
                     /**
                      * Adds or replaces a role by its name.
                      */
                     public Builder addRole(Role role) {
                         Objects.requireNonNull(role, "role can't be null");
                         roles.put(role.getName(), role);
                         return this;
                     }
                     /**
                      * Adds or replaces a layer by its name.
                      */
                     public Builder addLayer(Layer layer) {
                         Objects.requireNonNull(layer, "layer can't be null");
                         layers.put(layer.getName(), layer);
                         return this;
                     }
                     /**
                      * Adds or replaces a variant by its name.
                      */
                     public Builder addVariant(Variant variant) {
                         Objects.requireNonNull(variant, "variant can't be null");
                         variants.put(variant.getName(), variant);
                         return this;
                     }
                     /**
                      * Adds a variant definition to be resolved during {@link #build()}.
                      */
                     public Builder addDefinition(VariantDefinition definition) {
                         Objects.requireNonNull(definition, "definition can't be null");
                         definitions.add(definition);
                         return this;
                     }
                     /**
                      * Resolves collected identities and definitions into an immutable view.
                      *
                      * Missing variant, role, or layer declarations referenced by definitions
                      * cause {@link InvalidUserDataException}.
                      */
                     public VariantsView build() {
                         var entries = definitions.stream()
                                 .flatMap(def -> def.getRoleBindings().get().stream()
                                         .map(layerRole -> createVariantRoleLayer(
                                                 def.getName(), // variantName
                                                 layerRole.roleName(),
                                                 layerRole.layerName())))
                                 .collect(Collectors.toSet());
                         return new VariantsView(
                                 Set.copyOf(layers.values()),
                                 Set.copyOf(roles.values()),
                                 Set.copyOf(variants.values()),
                                 entries);
                     }
                     private VariantRoleLayer createVariantRoleLayer(String variantName, String roleName, String layerName) {
                         return new VariantRoleLayer(
                                 resolveVariant(variantName,
                                         "Variant '" + variantName + "' isn't declared"),
                                 resolveRole(roleName,
                                         "Role '" + roleName + "' isn't declared, referenced in '" + variantName + "' variant"),
                                 resolveLayer(layerName,
                                         "Layer '" + layerName + "' isn't declared, referenced in '" + variantName
                                                 + "' variant with '" + roleName + "' role"));
                     }
                     private Layer resolveLayer(String layerName, String errorMessage) {
                         return Optional.ofNullable(layers.get(layerName))
                                 .orElseThrow(() -> new InvalidUserDataException(errorMessage));
                     }
                     private Variant resolveVariant(String variantName, String errorMessage) {
                         return Optional.ofNullable(variants.get(variantName))
                                 .orElseThrow(() -> new InvalidUserDataException(errorMessage));
                     }
                     private Role resolveRole(String roleName, String errorMessage) {
                         return Optional.ofNullable(roles.get(roleName))
                                 .orElseThrow(() -> new InvalidUserDataException(errorMessage));
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/CompileUnitsView.java +2 -1

             package org.implab.gradle.variants.sources;
             import java.util.HashMap;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Optional;
             import java.util.Set;
             import java.util.stream.Collectors;
             import org.eclipse.jdt.annotation.NonNullByDefault;
+            import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
             @NonNullByDefault
             public final class CompileUnitsView {
                 private final VariantsView variants;
                 private final Map<Variant, Set<CompileUnit>> unitsByVariant = new HashMap<>();
                 private CompileUnitsView(VariantsView variants) {
                     this.variants = variants;
                 }
                 public Set<CompileUnit> getUnits() {
                     return variants.getEntries().stream()
                             .map(CompileUnit::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public Set<CompileUnit> getUnitsForVariant(Variant variant) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     return unitsByVariant.computeIfAbsent(variant, key -> variants
                             .getEntriesForVariant(variant).stream()
                             .map(CompileUnit::of)
                             .collect(Collectors.toUnmodifiableSet()));
                 }
                 public Optional<CompileUnit> findUnit(Variant variant, Layer layer) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     Objects.requireNonNull(layer, "Layer can't be null");
                     return getUnitsForVariant(variant).stream()
                             .filter(u -> u.layer().equals(layer))
                             .findAny();
                 }
                 public boolean contains(Variant variant, Layer layer) {
                     return findUnit(variant, layer).isPresent();
                 }
                 /**
                  * In which logical roles this compile unit participates.
                  */
                 public Set<Role> getRoles(CompileUnit unit) {
                     Objects.requireNonNull(unit, "Compile unit can't be null");
                     return variants.getEntriesForVariant(unit.variant()).stream()
                             .filter(entry -> entry.layer().equals(unit.layer()))
                             .map(VariantRoleLayer::role)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public CompileUnit requireUnit(Variant variant, Layer layer) {
                     return findUnit(variant, layer)
-                            .orElseThrow(() -> new IllegalArgumentException(
+                            .orElseThrow(() -> new InvalidUserDataException(
                                     "Compile unit for variant '" + variant.getName()
                                             + "' and layer '" + layer.getName() + "' not found"));
                 }
                 public static CompileUnitsView of(VariantsView variantsView) {
                     Objects.requireNonNull(variantsView, "variantsView can't be null");
                     return new CompileUnitsView(variantsView);
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/RoleProjectionsView.java +3 -1

             package org.implab.gradle.variants.sources;
             import java.util.HashMap;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Optional;
             import java.util.Set;
             import java.util.stream.Collectors;
+            import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             public final class RoleProjectionsView {
                 private final VariantsView variants;
                 private final Map<Variant, Set<RoleProjection>> projectionsByVariant = new HashMap<>();
                 private RoleProjectionsView(VariantsView variants) {
                     this.variants = variants;
                 }
                 public Set<RoleProjection> getProjections() {
                     return variants.getEntries().stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public Set<RoleProjection> getProjectionsForVariant(Variant variant) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     return projectionsByVariant.computeIfAbsent(variant, key -> variants
                             .getEntriesForVariant(variant).stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet()));
                 }
                 public Set<RoleProjection> getProjectionsForRole(Role role) {
                     Objects.requireNonNull(role, "Role can't be null");
                     return variants.getEntriesForRole(role).stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public Optional<RoleProjection> findProjection(Variant variant, Role role) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     Objects.requireNonNull(role, "Role can't be null");
                     return variants.getEntriesForVariant(variant).stream()
                             .filter(entry -> entry.role().equals(role))
                             .map(RoleProjection::of)
                             .findAny();
                 }
                 public boolean contains(Variant variant, Role role) {
                     return findProjection(variant, role).isPresent();
                 }
                 public Set<CompileUnit> getUnits(RoleProjection projection) {
                     Objects.requireNonNull(projection, "Role projection can't be null");
                     return variants.getEntriesForVariant(projection.variant()).stream()
                             .filter(entry -> entry.role().equals(projection.role()))
                             .map(CompileUnit::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public RoleProjection requireProjection(Variant variant, Role role) {
                     return findProjection(variant, role)
-                            .orElseThrow(() -> new IllegalArgumentException(
+                            .orElseThrow(() -> new InvalidUserDataException(
                                     "Role projection for variant '" + variant.getName()
                                             + "' and role '" + role.getName() + "' not found"));
                 }
                 public Set<Layer> getLayers(RoleProjection projection) {
                     return getUnits(projection).stream()
                             .map(CompileUnit::layer)
                             .collect(java.util.stream.Collectors.toUnmodifiableSet());
                 }
                 public static RoleProjectionsView of(VariantsView variantsView) {
+                    Objects.requireNonNull(variantsView, "variantsView can't be null");
                     return new RoleProjectionsView(variantsView);
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/SourceSetMaterializer.java +3 0

             package org.implab.gradle.variants.sources;
             import org.gradle.api.NamedDomainObjectProvider;
             /**
              * Materializes symbolic source set names into actual {@link GenericSourceSet}
              * instances.
              *
              * <p>Symbolic names are assigned from the finalized compile-unit model using
              * the selected
              * {@link VariantSourcesExtension#namingPolicy(org.gradle.api.Action)}.
              */
             public interface SourceSetMaterializer {
                 /**
                  * Returns a lazy provider for the source set corresponding to the compile unit.
                  *
                  * <p>The provider is stable and cached per compile unit.
+                 *
+                 * @throws org.gradle.api.InvalidUserDataException if the compile unit is not
+                 *         part of the finalized variant model
                  */
                 NamedDomainObjectProvider<GenericSourceSet> getSourceSet(CompileUnit unit);
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesContext.java +9 0

             package org.implab.gradle.variants.sources;
             import org.gradle.api.Action;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             /**
              * Registry of symbolic source set names produced by sources projection.
              *
              * <p>Identity in this registry is the {@link GenericSourceSet} name assigned
              * by the finalized
              * {@link VariantSourcesExtension#namingPolicy(org.gradle.api.Action)}.
              */
             public interface VariantSourcesContext {
                /**
                  * Finalized core model.
                  */
                 VariantsView getVariants();
                 /**
                  * Derived compile-side view.
                  */
                 CompileUnitsView getCompileUnits();
                 /**
                  * Derived role-side view.
                  */
                 RoleProjectionsView getRoleProjections();
                 /**
                  * Lazy source set provider service.
                  */
                 SourceSetMaterializer getSourceSets();
                 /**
                  * Configures all GenericSourceSets produced from the given layer.
                  *
                  * The action is applied:
                  * - to already materialized source sets of this layer
                  * - to all future source sets of this layer
                  *
                  * <p>For future source sets, selector precedence and registration order are
                  * preserved by the materializer.
                  *
                  * <p>For already materialized source sets, behavior is governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
                  * In warn/allow modes the action is applied as a late imperative step and does
                  * not retroactively restore selector precedence.
+                 *
+                 * @throws org.gradle.api.InvalidUserDataException if the layer is not part of
+                 *         the finalized variant model
                  */
                 void configureLayer(Layer layer, Action<? super GenericSourceSet> action);
                 /**
                  * Configures all GenericSourceSets produced from the given variant.
                  *
                  * <p>Late application semantics for already materialized source sets are
                  * governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
+                 *
+                 * @throws org.gradle.api.InvalidUserDataException if the variant is not part
+                 *         of the finalized variant model
                  */
                 void configureVariant(Variant variant, Action<? super GenericSourceSet> action);
                 /**
                  * Configures the GenericSourceSet produced from the given compile unit.
                  *
                  * <p>Late application semantics for already materialized source sets are
                  * governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
+                 *
+                 * @throws org.gradle.api.InvalidUserDataException if the compile unit is not
+                 *         part of the finalized variant model
                  */
                 void configureUnit(CompileUnit unit, Action<? super GenericSourceSet> action);
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesExtension.java +1 -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>it must be selected before the source context becomes observable via
                  * {@link #whenAvailable(Action)};</li>
                  * <li>once selected or once source context creation begins, 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 source
                  * context is created from the finalized variant model.
                  *
                  * <p>This policy is single-valued:
                  * <ul>
-                 * <li>it must be selected before the finalized
+                 * <li>it must be selected before the
                  * {@link VariantSourcesContext} becomes observable through
                  * {@link #whenAvailable(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 the 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 whenAvailable(Action<? super VariantSourcesContext> action);
                 default void whenAvailable(Closure<?> closure) {
                     whenAvailable(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/CompileUnitNamer.java +1 -1

             package org.implab.gradle.variants.sources.internal;
             import java.text.MessageFormat;
             import java.util.Collection;
             import java.util.Comparator;
             import java.util.HashMap;
             import java.util.HashSet;
             import java.util.Map;
             import java.util.Optional;
             import java.util.Set;
             import java.util.function.Function;
             import java.util.stream.Collectors;
             import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.common.core.lang.Strings;
             import org.implab.gradle.variants.sources.CompileUnit;
             public interface CompileUnitNamer {
                 String resolveName(CompileUnit unit);
                 public static Builder builder() {
                     return new Builder();
                 }
                 static class Builder {
                     private final Set<CompileUnit> units = new HashSet<>();
                     private NameCollisionPolicy nameCollisionPolicy = NameCollisionPolicy.FAIL;
                     private Builder() {
                     }
                     public Builder addUnits(Collection<CompileUnit> other) {
                         units.addAll(other);
                         return this;
                     }
                     public Builder nameCollisionPolicy(NameCollisionPolicy policy) {
                         nameCollisionPolicy = policy;
                         return this;
                     }
                     public CompileUnitNamer build() {
                         Map<String, Integer> seen = new HashMap<>();
                         if (nameCollisionPolicy == NameCollisionPolicy.FAIL) {
                             var collisions = units.stream()
                                     .collect(Collectors.groupingBy(this::projectName))
                                     .entrySet().stream()
                                     .filter(pair -> pair.getValue().size() > 1)
                                     .map(pair -> MessageFormat.format(
                                             "({0}: {1})",
                                             pair.getKey(),
                                             pair.getValue().stream()
                                                     .map(Object::toString)
                                                     .collect(Collectors.joining(","))))
                                     .collect(Collectors.joining(","));
                             if (!collisions.isEmpty())
                                 throw new InvalidUserDataException(
                                         "The same source set names are produced by different compile units: " + collisions);
                         }
                         var unitNames = units.stream()
                                 .sorted(Comparator
                                         .comparing((CompileUnit unit) -> unit.variant().getName())
                                         .thenComparing(unit -> unit.layer().getName()))
                                 .collect(Collectors.toUnmodifiableMap(Function.identity(), unit -> {
                                     var baseName = projectName(unit);
                                     var c = seen.compute(baseName, (key, count) -> count == null ? 1 : count + 1);
                                     return c == 1 ? baseName : baseName + String.valueOf(c);
                                 }));
                         return new CompileUnitNamer() {
                             @Override
                             public String resolveName(CompileUnit unit) {
                                 return Optional.ofNullable(unitNames.get(unit)).orElseThrow(
-                                        () -> new IllegalArgumentException(MessageFormat.format(
+                                        () -> new InvalidUserDataException(MessageFormat.format(
                                                 "Compile unit {0} doesn't have an associated name",
                                                 unit)));
                             }
                         };
                     }
                     private String projectName(CompileUnit unit) {
                         return unit.variant().getName() + Strings.capitalize(unit.layer().getName());
                     }
                 }
             }

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

             package org.implab.gradle.variants.sources.internal;
+            import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.variants.sources.VariantSourcesExtension.NamingPolicySpec;
             public class DefaultCompileUnitNamingPolicy implements NamingPolicySpec {
                 private NameCollisionPolicy policy = NameCollisionPolicy.FAIL;
                 private boolean policyApplied = false;
                 public NameCollisionPolicy policy() {
                     finalizePolicy();
                     return policy;
                 }
                 public void finalizePolicy() {
                     policyApplied = true;
                 }
                 @Override
                 public void failOnNameCollision() {
                     assertApplyOnce();
                     policy = NameCollisionPolicy.FAIL;
                 }
                 @Override
                 public void resolveNameCollision() {
                     assertApplyOnce();
                     policy = NameCollisionPolicy.RESOLVE;
                 }
                 private void assertApplyOnce() {
                     if (policyApplied)
-                        throw new IllegalStateException("Naming policy already applied");
+                        throw new InvalidUserDataException("Naming policy already applied");
                     policyApplied = true;
                 }
             }

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

             package org.implab.gradle.variants.sources.internal;
+            import org.gradle.api.InvalidUserDataException;
             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");
+                        throw new InvalidUserDataException("Lazy configuration policy already applied");
                     policyApplied = true;
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/internal/DefaultVariantSourcesContext.java +15 0

             package org.implab.gradle.variants.sources.internal;
             import java.util.HashMap;
             import java.util.Map;
+            import java.util.Objects;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectProvider;
             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.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.SourceSetMaterializer;
             import org.implab.gradle.variants.sources.VariantSourcesContext;
             public class DefaultVariantSourcesContext implements VariantSourcesContext {
                 private final VariantsView variantsView;
                 private final CompileUnitsView compileUnitsView;
                 private final RoleProjectionsView roleProjectionsView;
                 private final SourceSetMaterializer sourceSetMaterializer;
                 private final SourceSetRegistry sourceSetRegistry;
                 private final CompileUnitNamer compileUnitNamer;
                 private final SourceSetConfigurationRegistry sourceSetConfigurationRegistry;
                 public DefaultVariantSourcesContext(
                         VariantsView variantsView,
                         CompileUnitsView compileUnitsView,
                         RoleProjectionsView roleProjectionsView,
                         CompileUnitNamer compileUnitNamer,
                         SourceSetRegistry sourceSetRegistry,
                         SourceSetConfigurationRegistry sourceSetConfigurationRegistry) {
                     this.variantsView = variantsView;
                     this.compileUnitNamer = compileUnitNamer;
                     this.compileUnitsView = compileUnitsView;
                     this.roleProjectionsView = roleProjectionsView;
                     this.sourceSetRegistry = sourceSetRegistry;
                     this.sourceSetConfigurationRegistry = sourceSetConfigurationRegistry;
                     sourceSetMaterializer = new LocalSourceSetMaterializer();
                 }
                 @Override
                 public VariantsView getVariants() {
                     return variantsView;
                 }
                 @Override
                 public CompileUnitsView getCompileUnits() {
                     return compileUnitsView;
                 }
                 @Override
                 public RoleProjectionsView getRoleProjections() {
                     return roleProjectionsView;
                 }
                 @Override
                 public SourceSetMaterializer getSourceSets() {
                     return sourceSetMaterializer;
                 }
                 @Override
                 public void configureLayer(Layer layer, Action<? super GenericSourceSet> action) {
+                    variantsView.assertLayer(layer);
+                    Objects.requireNonNull(action, "action can't be null");
                     sourceSetConfigurationRegistry.addLayerAction(layer, action);
                 }
                 @Override
                 public void configureVariant(Variant variant, Action<? super GenericSourceSet> action) {
+                    variantsView.assertVariant(variant);
+                    Objects.requireNonNull(action, "action can't be null");
                     sourceSetConfigurationRegistry.addVariantAction(variant, action);
                 }
                 @Override
                 public void configureUnit(CompileUnit unit, Action<? super GenericSourceSet> action) {
+                    assertCompileUnit(unit);
+                    Objects.requireNonNull(action, "action can't be null");
                     sourceSetConfigurationRegistry.addCompileUnitAction(unit, action);
                 }
+                private void assertCompileUnit(CompileUnit unit) {
+                    Objects.requireNonNull(unit, "unit can't be null");
+                    variantsView.assertVariant(unit.variant());
+                    variantsView.assertLayer(unit.layer());
+                    compileUnitsView.requireUnit(unit.variant(), unit.layer());
+                }
                 class LocalSourceSetMaterializer implements SourceSetMaterializer {
                     private final Map<CompileUnit, NamedDomainObjectProvider<GenericSourceSet>> registeredSources = new HashMap<>();
                     @Override
                     public NamedDomainObjectProvider<GenericSourceSet> getSourceSet(CompileUnit unit) {
+                        assertCompileUnit(unit);
                         return registeredSources.computeIfAbsent(unit, k -> {
                             var sourcesName = compileUnitNamer.resolveName(unit);
                             sourceSetRegistry.whenMaterialized(sourcesName,
                                     sourceSet -> sourceSetConfigurationRegistry.applyConfiguration(unit, sourceSet));
                             return sourceSetRegistry.sourceSets().register(sourcesName);
                         });
                     }
                 }
             }

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

             package org.implab.gradle.variants.sources.internal;
             import java.text.MessageFormat;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.function.Supplier;
             import java.util.stream.Collectors;
             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.logging.Logger;
             import org.gradle.api.logging.Logging;
             import org.implab.gradle.common.core.lang.ReplayableQueue;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.implab.gradle.variants.sources.GenericSourceSet;
             @NonNullByDefault
             public class SourceSetConfigurationRegistry {
                 private static final Logger logger = Logging.getLogger(SourceSetConfigurationRegistry.class);
                 private final Map<Layer, ReplayableQueue<GenericSourceSet>> sourcesByLayer = new LinkedHashMap<>();
                 private final Map<Variant, ReplayableQueue<GenericSourceSet>> sourcesByVariant = new LinkedHashMap<>();
                 private final Map<CompileUnit, ReplayableQueue<GenericSourceSet>> sourcesByUnit = new LinkedHashMap<>();
                 private final Supplier<LateConfigurationMode> lateConfigurationMode;
                 public SourceSetConfigurationRegistry(Supplier<LateConfigurationMode> lateConfigurationMode) {
                     this.lateConfigurationMode = lateConfigurationMode;
                 }
                 public void addLayerAction(Layer layer, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByLayer.computeIfAbsent(layer, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source sets for [layer={0}] layer already materialized",
                                     layer.getName()));
                 }
                 public void addVariantAction(Variant variant, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByVariant.computeIfAbsent(variant, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source sets for [variant={0}] variant already materialized",
                                     variant.getName()));
                 }
                 public void addCompileUnitAction(CompileUnit unit, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source set for [variant={0}, layer={1}] already materialized",
                                     unit.variant().getName(),
                                     unit.layer().getName()));
                 }
                 private void addToActions(
                         ReplayableQueue<GenericSourceSet> actions,
                         Action<? super GenericSourceSet> action,
                         String assertMessage) {
                     assertLazyConfiguration(actions.values(), assertMessage);
                     actions.forEach(action::execute);
                 }
                 void assertLazyConfiguration(List<GenericSourceSet> sets, String message) {
                     if (sets.size() == 0)
                         return;
                     var names = sets.stream().map(Named::getName).collect(Collectors.joining(", "));
                     switch (lateConfigurationMode.get()) {
                         case FAIL:
-                            throw new IllegalStateException(message + " [" + names + "]");
+                            throw new InvalidUserDataException(message + " [" + names + "]");
                         case WARN:
                             logger.warn(message + "\n\t" + names);
                             break;
                         default:
                             break;
                     }
                 }
                 public void applyConfiguration(CompileUnit unit, GenericSourceSet sourceSet) {
                     sourcesByVariant.computeIfAbsent(unit.variant(), key -> new ReplayableQueue<>()).add(sourceSet);
                     sourcesByLayer.computeIfAbsent(unit.layer(), key -> new ReplayableQueue<>()).add(sourceSet);
                     sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()).add(sourceSet);
                 }
             }

variants/src/test/java/org/implab/gradle/variants/VariantSourcesPluginFunctionalTest.java +100 0

             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.whenAvailable { 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.whenAvailable { 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.whenAvailable { 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.whenAvailable { 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.whenAvailable { 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.whenAvailable { 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.whenAvailable { 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' isn't declared", "help");
                 }
                 @Test
+                void failsOnUnknownVariantContextSelectorTarget() throws Exception {
+                    writeSettings("variant-sources-context-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.whenAvailable { ctx ->
+                                def missing = objects.named(org.implab.gradle.variants.core.Variant, 'missing')
+                                ctx.configureVariant(missing) {
+                                    declareOutputs('js')
+                                }
+                            }
+                            """);
+                    assertBuildFails("The specified 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 failsOnUnknownLayerContextSelectorTarget() throws Exception {
+                    writeSettings("variant-sources-context-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.whenAvailable { ctx ->
+                                def missing = objects.named(org.implab.gradle.variants.core.Layer, 'missing')
+                                ctx.configureLayer(missing) {
+                                    declareOutputs('js')
+                                }
+                            }
+                            """);
+                    assertBuildFails("The specified 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 failsOnUndeclaredCompileUnitContextSelectorTarget() throws Exception {
+                    writeSettings("variant-sources-context-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.whenAvailable { ctx ->
+                                def browser = ctx.variants.variants.find { it.name == 'browser' }
+                                def testLayer = ctx.variants.layers.find { it.name == 'test' }
+                                def unit = new org.implab.gradle.variants.sources.CompileUnit(browser, testLayer)
+                                ctx.configureUnit(unit) {
+                                    declareOutputs('js')
+                                }
+                            }
+                            """);
+                    assertBuildFails("Compile unit for variant 'browser' and layer 'test' not found", "help");
+                }
+                @Test
+                void failsOnUndeclaredCompileUnitMaterializerTarget() throws Exception {
+                    writeSettings("variant-sources-materializer-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.whenAvailable { ctx ->
+                                def browser = ctx.variants.variants.find { it.name == 'browser' }
+                                def testLayer = ctx.variants.layers.find { it.name == 'test' }
+                                def unit = new org.implab.gradle.variants.sources.CompileUnit(browser, testLayer)
+                                ctx.sourceSets.getSourceSet(unit)
+                            }
+                            """);
+                    assertBuildFails("Compile unit for variant 'browser' and layer 'test' not found", "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.whenAvailable {
                                 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.whenAvailable {
                                 variantSources.lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             """);
                     assertBuildFails("Lazy configuration policy already applied", "help");
                 }
             }

variants/src/test/java/org/implab/gradle/variants/sources/CompileUnitsViewTest.java +2 -1

             package org.implab.gradle.variants.sources;
             import static org.junit.jupiter.api.Assertions.assertEquals;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.lang.reflect.Constructor;
             import java.util.Set;
+            import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
             import org.junit.jupiter.api.Test;
             class CompileUnitsViewTest {
                 @Test
                 void deduplicatesCompileUnitsAcrossRolesAndExposesParticipatingRoles() {
                     var browser = new TestVariant("browser");
                     var main = new TestLayer("main");
                     var test = new TestLayer("test");
                     var production = new TestRole("production");
                     var qa = new TestRole("test");
                     var view = view(
                             Set.of(main, test),
                             Set.of(production, qa),
                             Set.of(browser),
                             Set.of(
                                     new VariantRoleLayer(browser, production, main),
                                     new VariantRoleLayer(browser, qa, main),
                                     new VariantRoleLayer(browser, qa, test)));
                     var units = CompileUnitsView.of(view);
                     var browserMain = units.requireUnit(browser, main);
                     var browserTest = units.requireUnit(browser, test);
                     assertEquals(2, units.getUnits().size());
                     assertEquals(Set.of(browserMain, browserTest), units.getUnitsForVariant(browser));
                     assertEquals(Set.of(production, qa), units.getRoles(browserMain));
                     assertEquals(Set.of(qa), units.getRoles(browserTest));
                     assertTrue(units.contains(browser, main));
                     assertTrue(units.contains(browser, test));
                 }
                 @Test
                 void rejectsMissingCompileUnitLookup() {
                     var browser = new TestVariant("browser");
                     var main = new TestLayer("main");
                     var missing = new TestLayer("missing");
                     var production = new TestRole("production");
                     var view = view(
                             Set.of(main),
                             Set.of(production),
                             Set.of(browser),
                             Set.of(new VariantRoleLayer(browser, production, main)));
                     var units = CompileUnitsView.of(view);
-                    var ex = assertThrows(IllegalArgumentException.class, () -> units.requireUnit(browser, missing));
+                    var ex = assertThrows(InvalidUserDataException.class, () -> units.requireUnit(browser, missing));
                     assertTrue(ex.getMessage().contains("Compile unit for variant 'browser' and layer 'missing' not found"));
                 }
                 private static VariantsView view(
                         Set<Layer> layers,
                         Set<Role> roles,
                         Set<Variant> variants,
                         Set<VariantRoleLayer> entries) {
                     try {
                         Constructor<VariantsView> ctor = VariantsView.class.getDeclaredConstructor(
                                 Set.class,
                                 Set.class,
                                 Set.class,
                                 Set.class);
                         ctor.setAccessible(true);
                         return ctor.newInstance(layers, roles, variants, entries);
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to create VariantsView fixture", e);
                     }
                 }
                 private record TestVariant(String value) implements Variant {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestLayer(String value) implements Layer {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestRole(String value) implements Role {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
             }

variants/src/test/java/org/implab/gradle/variants/sources/RoleProjectionsViewTest.java +2 -1

             package org.implab.gradle.variants.sources;
             import static org.junit.jupiter.api.Assertions.assertEquals;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.lang.reflect.Constructor;
             import java.util.Set;
+            import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
             import org.junit.jupiter.api.Test;
             class RoleProjectionsViewTest {
                 @Test
                 void exposesRoleProjectionsAndTheirCompileUnits() {
                     var browser = new TestVariant("browser");
                     var main = new TestLayer("main");
                     var test = new TestLayer("test");
                     var production = new TestRole("production");
                     var qa = new TestRole("test");
                     var view = view(
                             Set.of(main, test),
                             Set.of(production, qa),
                             Set.of(browser),
                             Set.of(
                                     new VariantRoleLayer(browser, production, main),
                                     new VariantRoleLayer(browser, qa, main),
                                     new VariantRoleLayer(browser, qa, test)));
                     var projections = RoleProjectionsView.of(view);
                     var productionProjection = projections.requireProjection(browser, production);
                     var qaProjection = projections.requireProjection(browser, qa);
                     assertEquals(Set.of(productionProjection, qaProjection), projections.getProjections());
                     assertEquals(Set.of(productionProjection, qaProjection), projections.getProjectionsForVariant(browser));
                     assertEquals(Set.of(qaProjection), projections.getProjectionsForRole(qa));
                     assertEquals(Set.of(new CompileUnit(browser, main)), projections.getUnits(productionProjection));
                     assertEquals(Set.of(new CompileUnit(browser, main), new CompileUnit(browser, test)), projections.getUnits(qaProjection));
                     assertEquals(Set.of(main, test), projections.getLayers(qaProjection));
                     assertTrue(projections.contains(browser, production));
                 }
                 @Test
                 void rejectsMissingProjectionLookup() {
                     var browser = new TestVariant("browser");
                     var node = new TestVariant("node");
                     var main = new TestLayer("main");
                     var production = new TestRole("production");
                     var view = view(
                             Set.of(main),
                             Set.of(production),
                             Set.of(browser, node),
                             Set.of(new VariantRoleLayer(browser, production, main)));
                     var projections = RoleProjectionsView.of(view);
-                    var ex = assertThrows(IllegalArgumentException.class, () -> projections.requireProjection(node, production));
+                    var ex = assertThrows(InvalidUserDataException.class, () -> projections.requireProjection(node, production));
                     assertTrue(ex.getMessage().contains("Role projection for variant 'node' and role 'production' not found"));
                 }
                 private static VariantsView view(
                         Set<Layer> layers,
                         Set<Role> roles,
                         Set<Variant> variants,
                         Set<VariantRoleLayer> entries) {
                     try {
                         Constructor<VariantsView> ctor = VariantsView.class.getDeclaredConstructor(
                                 Set.class,
                                 Set.class,
                                 Set.class,
                                 Set.class);
                         ctor.setAccessible(true);
                         return ctor.newInstance(layers, roles, variants, entries);
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to create VariantsView fixture", e);
                     }
                 }
                 private record TestVariant(String value) implements Variant {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestLayer(String value) implements Layer {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestRole(String value) implements Role {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
             }

variants/src/test/java/org/implab/gradle/variants/sources/internal/CompileUnitNamerTest.java +1 -1

             package org.implab.gradle.variants.sources.internal;
             import static org.junit.jupiter.api.Assertions.assertEquals;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.util.List;
             import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.junit.jupiter.api.Test;
             class CompileUnitNamerTest {
                 @Test
                 void resolvesProjectedNameForUniqueCompileUnit() {
                     var unit = unit("browser", "main");
                     var namer = CompileUnitNamer.builder()
                             .addUnits(List.of(unit))
                             .build();
                     assertEquals("browserMain", namer.resolveName(unit));
                 }
                 @Test
                 void failsOnProjectedNameCollisionInFailMode() {
                     var left = unit("foo", "variantBar");
                     var right = unit("fooVariant", "bar");
                     var ex = assertThrows(
                             InvalidUserDataException.class,
                             () -> CompileUnitNamer.builder()
                                     .addUnits(List.of(left, right))
                                     .nameCollisionPolicy(NameCollisionPolicy.FAIL)
                                     .build());
                     assertTrue(ex.getMessage().contains("The same source set names are produced by different compile units"));
                     assertTrue(ex.getMessage().contains("fooVariantBar"));
                 }
                 @Test
                 void resolvesProjectedNameCollisionDeterministicallyInCanonicalOrder() {
                     var earlier = unit("foo", "variantBar");
                     var later = unit("fooVariant", "bar");
                     var namer = CompileUnitNamer.builder()
                             .addUnits(List.of(later, earlier))
                             .nameCollisionPolicy(NameCollisionPolicy.RESOLVE)
                             .build();
                     assertEquals("fooVariantBar", namer.resolveName(earlier));
                     assertEquals("fooVariantBar2", namer.resolveName(later));
                 }
                 @Test
                 void rejectsUnknownCompileUnitLookup() {
                     var known = unit("browser", "main");
                     var unknown = unit("browser", "test");
                     var namer = CompileUnitNamer.builder()
                             .addUnits(List.of(known))
                             .build();
-                    var ex = assertThrows(IllegalArgumentException.class, () -> namer.resolveName(unknown));
+                    var ex = assertThrows(InvalidUserDataException.class, () -> namer.resolveName(unknown));
                     assertTrue(ex.getMessage().contains("Compile unit"));
                     assertTrue(ex.getMessage().contains("associated name"));
                 }
                 private static CompileUnit unit(String variantName, String layerName) {
                     return new CompileUnit(
                             new TestVariant(variantName),
                             new TestLayer(layerName));
                 }
                 private record TestVariant(String value) implements Variant {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestLayer(String value) implements Layer {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
             }

variants/src/test/java/org/implab/gradle/variants/sources/internal/DefaultCompileUnitNamingPolicyTest.java +3 -2

             package org.implab.gradle.variants.sources.internal;
             import static org.junit.jupiter.api.Assertions.assertEquals;
             import static org.junit.jupiter.api.Assertions.assertThrows;
+            import org.gradle.api.InvalidUserDataException;
             import org.junit.jupiter.api.Test;
             class DefaultCompileUnitNamingPolicyTest {
                 @Test
                 void usesFailPolicyByDefault() {
                     var policy = new DefaultCompileUnitNamingPolicy();
                     assertEquals(NameCollisionPolicy.FAIL, policy.policy());
                 }
                 @Test
                 void switchesToResolvePolicyWhenSelected() {
                     var policy = new DefaultCompileUnitNamingPolicy();
                     policy.resolveNameCollision();
                     assertEquals(NameCollisionPolicy.RESOLVE, policy.policy());
                 }
                 @Test
                 void rejectsChangingPolicyAfterItWasSelected() {
                     var policy = new DefaultCompileUnitNamingPolicy();
                     policy.resolveNameCollision();
-                    assertThrows(IllegalStateException.class, policy::failOnNameCollision);
+                    assertThrows(InvalidUserDataException.class, policy::failOnNameCollision);
                 }
                 @Test
                 void rejectsChangingPolicyAfterItWasFinalized() {
                     var policy = new DefaultCompileUnitNamingPolicy();
                     policy.finalizePolicy();
-                    assertThrows(IllegalStateException.class, policy::resolveNameCollision);
+                    assertThrows(InvalidUserDataException.class, policy::resolveNameCollision);
                 }
             }

variants/src/test/java/org/implab/gradle/variants/sources/internal/DefaultLateConfigurationPolicySpecTest.java +3 -2

             package org.implab.gradle.variants.sources.internal;
             import static org.junit.jupiter.api.Assertions.assertEquals;
             import static org.junit.jupiter.api.Assertions.assertThrows;
+            import org.gradle.api.InvalidUserDataException;
             import org.junit.jupiter.api.Test;
             class DefaultLateConfigurationPolicySpecTest {
                 @Test
                 void usesFailModeByDefault() {
                     var policy = new DefaultLateConfigurationPolicySpec();
                     assertEquals(LateConfigurationMode.FAIL, policy.mode());
                 }
                 @Test
                 void switchesToWarnModeWhenSelected() {
                     var policy = new DefaultLateConfigurationPolicySpec();
                     policy.warnOnLateConfiguration();
                     assertEquals(LateConfigurationMode.WARN, policy.mode());
                 }
                 @Test
                 void switchesToApplyModeWhenSelected() {
                     var policy = new DefaultLateConfigurationPolicySpec();
                     policy.allowLateConfiguration();
                     assertEquals(LateConfigurationMode.APPLY, policy.mode());
                 }
                 @Test
                 void rejectsChangingPolicyAfterItWasSelected() {
                     var policy = new DefaultLateConfigurationPolicySpec();
                     policy.warnOnLateConfiguration();
-                    assertThrows(IllegalStateException.class, policy::failOnLateConfiguration);
+                    assertThrows(InvalidUserDataException.class, policy::failOnLateConfiguration);
                 }
                 @Test
                 void rejectsChangingPolicyAfterItWasFinalized() {
                     var policy = new DefaultLateConfigurationPolicySpec();
                     policy.finalizePolicy();
-                    assertThrows(IllegalStateException.class, policy::allowLateConfiguration);
+                    assertThrows(InvalidUserDataException.class, policy::allowLateConfiguration);
                 }
             }

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