implab/gradle-common Commit - r59:780370baa54c

variants: move source set layout conventions out of model...

cin -

r59:780370baa54c default

parent child

Context file:

r59:780370baa54c

Collapse all files

variants/src/main/java/org/implab/gradle/variants/sources/internal/CompileUnitLayoutConvention.java created 644 +45 0

@@ -0,0 +1,45
	1	package org.implab.gradle.variants.sources.internal;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.file.Directory;
	5	import org.gradle.api.provider.Provider;
	6	import org.implab.gradle.common.core.lang.FilePaths;
	7	import org.implab.gradle.variants.sources.CompileUnitSourceSetSpec;
	8
	9	/**
	10	* Applies the default layout policy for source sets materialized from variant
	11	* compile units.
	12	*
	13	* <p>
	14	* The convention keeps sources grouped by layer and outputs grouped by
	15	* variant/layer. It only sets directory properties on the materialized source
	16	* set; declaring source directories and named outputs remains the
	17	* responsibility of adapters or user DSL.
	18	* </p>
	19	*/
	20	public class CompileUnitLayoutConvention implements Action<CompileUnitSourceSetSpec> {
	21	private final Provider<Directory> sourcesBaseDir;
	22	private final Provider<Directory> outputsBaseDir;
	23
	24	public CompileUnitLayoutConvention(
	25	Provider<Directory> baseDirectory,
	26	Provider<Directory> outputsBaseDir) {
	27	this.sourcesBaseDir = baseDirectory;
	28	this.outputsBaseDir = outputsBaseDir;
	29	}
	30
	31	@Override
	32	public void execute(CompileUnitSourceSetSpec spec) {
	33	var sourceSet = spec.getSourceSet();
	34	var unit = spec.getCompileUnit();
	35	var layerName = unit.layer().getName();
	36	var variantName = unit.variant().getName();
	37
	38	sourceSet.getSourceSetDir()
	39	.convention(sourcesBaseDir.map(base -> base.dir(FilePaths.cat(layerName))));
	40
	41	sourceSet.getOutputsDir()
	42	.convention(outputsBaseDir.map(base -> base.dir(FilePaths.cat(variantName, layerName))));
	43	}
	44
	45	}

.vscode/settings.json +2 -1

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

variants/src/main/java/org/implab/gradle/variants/SourcesPlugin.java +19 -2

             package org.implab.gradle.variants;
             import org.gradle.api.GradleException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
+            import org.implab.gradle.common.core.lang.FilePaths;
             import org.implab.gradle.variants.sources.GenericSourceSet;
             /**
              * This plugin creates a {@code sources} extension which is
              * a container for {@link GenericSourceSet}.
              *
              */
             public abstract class SourcesPlugin implements Plugin<Project> {
                 private static final Logger logger = Logging.getLogger(SourcesPlugin.class);
-                private static final String SOURCES_EXTENSION_NAME = "sources";
+                public static final String SOURCES_EXTENSION_NAME = "sources";
+                private static final String SOURCES_DIRECTORY = "src";
+                private static final String OUTPUTS_DIRECTORY = "out";
                 @Override
                 public void apply(Project target) {
                     logger.debug("Registering '{}' extension on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
+                    var layout = target.getLayout();
                     var sources = target.getObjects().domainObjectContainer(GenericSourceSet.class);
+                    sources.configureEach(sourceSet -> {
+                        sourceSet.getSourceSetDir()
+                                .convention(layout.getProjectDirectory()
+                                        .dir(FilePaths.cat(SOURCES_DIRECTORY, sourceSet.getName())));
+                        sourceSet.getOutputsDir()
+                                .convention(layout.getBuildDirectory()
+                                        .dir(FilePaths.cat(OUTPUTS_DIRECTORY, sourceSet.getName())));
+                    });
                     target.getExtensions().add(SOURCES_EXTENSION_NAME, sources);
                 }
                 public static NamedDomainObjectContainer<GenericSourceSet> getSourcesExtension(Project target) {
                     var extensions = target.getExtensions();
                     @SuppressWarnings("unchecked")
                     var extension = (NamedDomainObjectContainer<GenericSourceSet>) extensions.findByName(SOURCES_EXTENSION_NAME);
                     if (extension == null) {
-                        logger.error("Sources extension '{}' isn't found on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
+                        logger.error("Sources extension '{}' isn't found on project '{}'", SOURCES_EXTENSION_NAME,
+                                target.getPath());
                         throw new GradleException("Sources extension isn't found");
                     }
                     logger.debug("Resolved '{}' extension on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                     return extension;
                 }
             }

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

             package org.implab.gradle.variants;
             import org.gradle.api.Action;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSpec;
             import org.implab.gradle.variants.artifacts.OutgoingVariantsContext;
             import org.implab.gradle.variants.artifacts.VariantArtifactsExtension;
             import org.implab.gradle.variants.artifacts.VariantArtifactsSpec;
             import org.implab.gradle.variants.artifacts.internal.ArtifactAssemblyBinder;
             import org.implab.gradle.variants.artifacts.internal.ArtifactAssemblyHandler;
             import org.implab.gradle.variants.artifacts.internal.ArtifactAssemblyRegistry;
             import org.implab.gradle.variants.artifacts.internal.DefaultOutgoingVariantsContext;
             import org.implab.gradle.variants.artifacts.internal.MaterializationPolicyHandler;
             import org.implab.gradle.variants.artifacts.internal.OutgoingRegistry;
             import org.implab.gradle.variants.artifacts.internal.SingleSlotConvention;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsExtension;
             import org.implab.gradle.variants.sources.VariantSourcesExtension;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSlotSpec;
             public abstract class VariantArtifactsPlugin implements Plugin<Project> {
+                public static final String VARIANT_ARTIFACTS_EXTENSION = "variantArtifacts";
                 @Override
                 public void apply(Project target) {
                     var extensions = target.getExtensions();
                     var objects = target.getObjects();
                     var providers = target.getProviders();
                     var plugins = target.getPlugins();
                     var configurations = target.getConfigurations();
                     var tasks = target.getTasks();
                     var layout = target.getLayout();
                     // Apply the main VariantsPlugin to ensure the core variant model is available.
                     plugins.apply(VariantsPlugin.class);
                     plugins.apply(VariantSourcesPlugin.class);
                     // Access the VariantsExtension to configure variant sources.
                     var variantsExtension = extensions.getByType(VariantsExtension.class);
                     var sourcesExtension = extensions.getByType(VariantSourcesExtension.class);
                     var deferred = new Deferred<OutgoingVariantsContext>();
                     variantsExtension.whenFinalized(variants -> {
                         var outgoing = new OutgoingRegistry(configurations, objects, variants.getVariants());
                         var assemblies = new ArtifactAssemblyRegistry();
                         // wire artifact assemblies to configuration variants
                         var assembliesBridge = new ArtifactAssemblyBinder(assemblies);
                         var primarySlotConvention = new SingleSlotConvention(providers);
                         var materializationHandler = new MaterializationPolicyHandler(objects);
                         // bind slot assemblies to outgoing variants
                         outgoing.configureEach(assembliesBridge::execute);
                         // apply primary slot convention when outgoing variant has a single slot
                         outgoing.configureEach(primarySlotConvention::execute);
                         // apply materialization policy hooks to outgoing variants
                         outgoing.configureEach(materializationHandler::execute);
                         sourcesExtension.whenAvailable(sources -> {
                             var assemblyHandler = new ArtifactAssemblyHandler(
                                     objects,
                                     tasks,
                                     assemblies,
                                     sources.getCompileUnits(),
                                     sources.getRoleProjections(),
                                     sources.getSourceSets());
                             assemblyHandler.getAssembliesDirectory().set(layout.getBuildDirectory().dir("variant-assemblies"));
                             deferred.resolve(new DefaultOutgoingVariantsContext(
                                     assemblies,
                                     outgoing,
                                     assemblyHandler,
                                     materializationHandler));
                         });
                     });
                     var variantArtifacts = new VariantArtifactsExtension() {
                         @Override
                         public void variant(String variantName, Action<? super VariantArtifactsSpec> action) {
                             deferred.whenResolved(context -> {
                                 var variant = objects.named(Variant.class, variantName);
                                 context.configureVariant(variant, action);
                             });
                         }
                         @Override
                         public void whenAvailable(Action<? super OutgoingVariantsContext> action) {
                             deferred.whenResolved(handler -> action.execute(handler));
                         }
                         @Override
                         public void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action) {
                             deferred.whenResolved(registry -> registry.whenOutgoingConfiguration(action));
                         }
                         @Override
                         public void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action) {
                             deferred.whenResolved(registry -> registry.whenOutgoingSlot(action));
                         }
                     };
-                    extensions.add(VariantArtifactsExtension.class, "variantArtifacts", variantArtifacts);
+                    extensions.add(VariantArtifactsExtension.class, VARIANT_ARTIFACTS_EXTENSION, variantArtifacts);
                 }
             }

variants/src/main/java/org/implab/gradle/variants/VariantSourcesPlugin.java +35 -46

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

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

             package org.implab.gradle.variants;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.core.lang.Deferred;
             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.VariantDefinition;
             import org.implab.gradle.variants.core.VariantsExtension;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.internal.IdentityContainerFactory;
             /**
              * <ul>
              * <li> {@link Variant} defines compilation semantics
              * <li> {@link Layer} defines compilation partition
              * <li> {@link Role} defines result grouping / publication intent
              * </ul>
              *
              */
             public abstract class VariantsPlugin implements Plugin<Project> {
+                public static final String VARIANTS_EXTENSION = "variants";
                 @Override
                 public void apply(Project target) {
                     var objectFactory = target.getObjects();
                     var variantsExtension = new DefaultVariantsExtension(objectFactory);
-                    target.getExtensions().add(VariantsExtension.class, "variants", variantsExtension);
+                    target.getExtensions().add(VariantsExtension.class, VARIANTS_EXTENSION, variantsExtension);
                     target.afterEvaluate(t -> variantsExtension.finalizeExtension());
                 }
                 static class DefaultVariantsExtension implements VariantsExtension {
                     private final NamedDomainObjectContainer<Layer> layers;
                     private final NamedDomainObjectContainer<Role> roles;
                     private final NamedDomainObjectContainer<VariantDefinition> variantDefinitions;
                     private final Deferred<VariantsView> finalizedResult = new Deferred<>();
                     private final ObjectFactory objectFactory;
                     private boolean finalized = false;
                     public DefaultVariantsExtension(ObjectFactory objectFactory) {
                         this.objectFactory = objectFactory;
                         this.layers = IdentityContainerFactory.create(objectFactory, Layer.class);
                         this.roles = IdentityContainerFactory.create(objectFactory, Role.class);
                         this.variantDefinitions = objectFactory.domainObjectContainer(VariantDefinition.class);
                     }
                     @Override
                     public NamedDomainObjectContainer<Layer> getLayers() {
                         return layers;
                     }
                     @Override
                     public NamedDomainObjectContainer<Role> getRoles() {
                         return roles;
                     }
                     @Override
                     public NamedDomainObjectContainer<VariantDefinition> getVariantDefinitions() {
                         return variantDefinitions;
                     }
                     @Override
                     public void whenFinalized(Action<? super VariantsView> action) {
                         finalizedResult.whenResolved(action::execute);
                     }
                     void finalizeExtension() {
                         if (finalized)
                             return;
                         finalized = true;
                         // freeze defined variants
                         variantDefinitions.forEach(VariantDefinition::finalizeVariant);
                         // build a snapshot
                         var viewBuilder = VariantsView.builder();
                         // calculate and add variants
                         variantDefinitions.stream()
                                 .map(def -> objectFactory.named(Variant.class, def.getName()))
                                 .forEach(viewBuilder::addVariant);
                         // add layers
                         layers.forEach(viewBuilder::addLayer);
                         // add roles
                         roles.forEach(viewBuilder::addRole);
                         // add definitions
                         variantDefinitions.forEach(viewBuilder::addDefinition);
                         // assemble the view
                         var view = viewBuilder.build();
                         // set the result and call hooks
                         finalizedResult.resolve(view);
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/GenericSourceSet.java +19 -18

             package org.implab.gradle.variants.sources;
             import java.io.File;
-            import java.nio.file.Paths;
             import java.util.HashSet;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Set;
             import java.util.concurrent.Callable;
             import java.util.function.Function;
             import java.util.stream.Collectors;
             import java.util.stream.Stream;
             import javax.inject.Inject;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.Task;
             import org.gradle.api.file.ConfigurableFileCollection;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.FileCollection;
-            import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.file.SourceDirectorySet;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.tasks.TaskProvider;
             /**
              * A configurable source set abstraction with named outputs.
              *
              * <p>
              * Each instance aggregates multiple {@link SourceDirectorySet source sets}
              * under a shared name and exposes typed outputs that must be declared up front.
-             * Default locations are {@code src/<name>} for sources and
+             * Source and output base directories are explicit model properties. They do
-             * {@code build/<name>} for outputs, both of which can be customized via the
+             * not define source directories or outputs by themselves; plugins and adapters
-             * exposed {@link DirectoryProperty} setters.
+             * may attach conventions or use them as layout hints for their own
+             * materialization rules.
              * </p>
              *
              * <p>
              * Outputs are grouped by names to make task wiring explicit. An output must be
              * declared with {@link #declareOutputs(String, String...)} before files can be
              * registered against it. Attempting to register or retrieve an undeclared
              * output results in
              * {@link InvalidUserDataException}.
              * </p>
              */
             public abstract class GenericSourceSet implements Named {
                 private final String name;
                 private final NamedDomainObjectContainer<SourceDirectorySet> sourceDirectorySets;
                 private final Map<String, ConfigurableFileCollection> outputs;
                 private final FileCollection allOutputs;
                 private final FileCollection allSourceDirectories;
                 private final ObjectFactory objects;
                 private final Set<String> declaredOutputs = new HashSet<>();
                 @Inject
-                public GenericSourceSet(String name, ObjectFactory objects, ProjectLayout layout) {
+                public GenericSourceSet(String name, ObjectFactory objects) {
                     this.name = name;
                     this.objects = objects;
                     sourceDirectorySets = objects.domainObjectContainer(
                             SourceDirectorySet.class,
                             this::createSourceDirectorySet);
                     outputs = new LinkedHashMap<>();
                     allSourceDirectories = objects.fileCollection().from(sourceDirectoriesProvider());
                     allOutputs = objects.fileCollection().from(outputsProvider());
-                    getSourceSetDir().convention(layout
-                            .getProjectDirectory()
-                            .dir(Paths.get("src", name).toString()));
-                    getOutputsDir().convention(layout
-                            .getBuildDirectory()
-                            .dir(name));
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 /**
-                 * Base directory for this source set. Defaults to {@code src/<name>} under
+                 * Base directory associated with this source set.
-                 * the project directory.
+                 * <p>
+                 * This property is intentionally convention-free in the base model. A
+                 * plugin may attach a convention when it knows the surrounding layout
+                 * policy, for example when materializing variant compile units.
+                 * </p>
                  */
                 public abstract DirectoryProperty getSourceSetDir();
                 /**
-                 * Base directory for outputs of this source set. Defaults to
+                 * Base directory associated with outputs of this source set.
-                 * {@code build/<name>}.
+                 * <p>
+                 * This property is a layout hint. Actual named outputs are declared and
+                 * populated through {@link #declareOutputs(String, String...)} and
+                 * {@link #registerOutput(String, Object...)}.
+                 * </p>
                  */
                 public abstract DirectoryProperty getOutputsDir();
                 /**
                  * The container of {@link SourceDirectorySet} instances that belong to this
                  * logical source set.
                  */
                 public NamedDomainObjectContainer<SourceDirectorySet> getSets() {
                     return sourceDirectorySets;
                 }
                 /**
                  * All registered outputs grouped across output names.
                  */
                 public FileCollection getAllOutputs() {
                     return allOutputs;
                 }
                 /**
                  * All source directories from every contained {@link SourceDirectorySet}.
                  */
                 public FileCollection getAllSourceDirectories() {
                     return allSourceDirectories;
                 }
                 /**
                  * Returns the file collection for the specified output name, creating it
                  * if necessary.
                  *
                  * @throws InvalidUserDataException if the output was not declared
                  */
                 public FileCollection output(String name) {
                     return configurableOutput(name);
                 }
                 private ConfigurableFileCollection configurableOutput(String name) {
                     requireDeclaredOutput(name);
                     return outputs.computeIfAbsent(name, key -> objects.fileCollection());
                 }
                 /**
                  * Declares allowed output names. Outputs must be declared before registering
                  * files under them.
                  */
                 public void declareOutputs(String name, String... extra) {
                     Stream.concat(Stream.of(name), Stream.of(extra))
                             .map(Objects::requireNonNull)
                             .forEach(declaredOutputs::add);
                 }
                 /**
                  * Registers files produced elsewhere under the given output.
                  */
                 public void registerOutput(String name, Object... files) {
                     configurableOutput(name).from(files);
                 }
                 /**
                  * Registers output files produced by a task, using a mapper to extract the
                  * output from the task. The task will be added as a build dependency of this
                  * output.
                  */
                 public <T extends Task> void registerOutput(String name, TaskProvider<T> task,
                         Function<? super T, ?> mapper) {
                     configurableOutput(name).from(task.map(mapper::apply))
                             .builtBy(task);
                 }
                 private SourceDirectorySet createSourceDirectorySet(String name) {
                     return objects.sourceDirectorySet(name, name);
                 }
                 private void requireDeclaredOutput(String outputName) {
                     if (!declaredOutputs.contains(outputName)) {
                         throw new InvalidUserDataException(
                                 "Output '" + outputName + "' is not declared for source set '" + name + "'");
                     }
                 }
                 private Callable<List<? extends FileCollection>> outputsProvider() {
                     return () -> outputs.values().stream().toList();
                 }
                 private Callable<Set<File>> sourceDirectoriesProvider() {
                     return () -> sourceDirectorySets.stream()
                             .flatMap(x -> x.getSrcDirs().stream())
                             .collect(Collectors.toSet());
                 }
             }

variants/src/test/java/org/implab/gradle/variants/PluginMarkerFunctionalTest.java +4 0

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertEquals;
             import static org.junit.jupiter.api.Assertions.assertNotNull;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.io.IOException;
             import java.util.Properties;
             import org.gradle.testkit.runner.BuildResult;
             import org.junit.jupiter.api.Test;
             class PluginMarkerFunctionalTest extends AbstractFunctionalTest {
                 @Test
                 void pluginMarkersPointToCurrentImplementations() throws Exception {
                     assertMarker("org.implab.gradle-variants.properties", VariantsPlugin.class);
                     assertMarker("org.implab.gradle-sources.properties", SourcesPlugin.class);
                     assertMarker("org.implab.gradle-variants-sources.properties", VariantSourcesPlugin.class);
                     assertMarker("org.implab.gradle-variants-artifacts.properties", VariantArtifactsPlugin.class);
                 }
                 @Test
                 void pluginIdsApplyCurrentExtensions() throws Exception {
                     writeSettings("variants-plugin-ids");
                     writeBuildFile("""
                             apply plugin: 'org.implab.gradle-variants'
                             apply plugin: 'org.implab.gradle-sources'
                             apply plugin: 'org.implab.gradle-variants-sources'
                             apply plugin: 'org.implab.gradle-variants-artifacts'
                             tasks.register('probe') {
                                 doLast {
                                     println("variantsExtension=" + (project.extensions.findByName('variants') != null))
                                     println("sourcesExtension=" + (project.extensions.findByName('sources') != null))
                                     println("variantSourcesExtension=" + (project.extensions.findByName('variantSources') != null))
                                     println("variantArtifactsExtension=" + (project.extensions.findByName('variantArtifacts') != null))
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("variantsExtension=true"));
                     assertTrue(result.getOutput().contains("sourcesExtension=true"));
                     assertTrue(result.getOutput().contains("variantSourcesExtension=true"));
                     assertTrue(result.getOutput().contains("variantArtifactsExtension=true"));
                 }
                 @Test
                 void sourcesPluginSupportsStandaloneSourceSetWorkflow() throws Exception {
                     writeSettings("sources-plugin-standalone");
                     writeFile("inputs/main.js", "console.log('main')\n");
                     writeBuildFile("""
                             apply plugin: 'org.implab.gradle-sources'
                             sources.create('main') {
                                 declareOutputs('js')
                                 registerOutput('js', layout.projectDirectory.file('inputs/main.js'))
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def main = sources.named('main').get()
                                     println("sourceSet=" + main.name)
+                                    println("sourceSetDir=" + project.relativePath(main.sourceSetDir.get().asFile))
+                                    println("outputsDir=" + project.relativePath(main.outputsDir.get().asFile))
                                     println("jsFiles=" + main.output('js').files.collect { it.name }.sort().join(','))
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("sourceSet=main"));
+                    assertTrue(result.getOutput().contains("sourceSetDir=src/main"));
+                    assertTrue(result.getOutput().contains("outputsDir=build/out/main"));
                     assertTrue(result.getOutput().contains("jsFiles=main.js"));
                 }
                 private static void assertMarker(String markerName, Class<?> implementationClass) throws IOException {
                     var resourceName = "META-INF/gradle-plugins/" + markerName;
                     var resource = PluginMarkerFunctionalTest.class.getClassLoader().getResourceAsStream(resourceName);
                     assertNotNull(resource, "Missing plugin marker " + resourceName);
                     var properties = new Properties();
                     properties.load(resource);
                     assertEquals(implementationClass.getName(), properties.getProperty("implementation-class"));
                 }
             }

variants/src/test/java/org/implab/gradle/variants/VariantSourcesPluginFunctionalTest.java +9 -4

             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)
+                                def sourceSet = left.get()
                                 lines << "projectionUnits=" + ctx.roleProjections.getUnits(projection)
                                     .collect { it.layer().name }
                                     .sort()
                                     .join(',')
-                                lines << "mainSourceSet=" + left.name
+                                lines << "mainSourceSet=" + sourceSet.name
+                                lines << "mainSourceSetDir=" + project.relativePath(sourceSet.sourceSetDir.get().asFile)
+                                lines << "mainOutputsDir=" + project.relativePath(sourceSet.outputsDir.get().asFile)
                                 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("mainSourceSetDir=src/main"));
+                    assertTrue(result.getOutput().contains("mainOutputsDir=build/variants/browser/main"));
                     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 {
                                 configureEach {
                                     events << "all:" + sourceSet.name
                                     events << "context:" + sourceSet.name + ":" + variant.name + ":" + layer.name
                                 }
                                 variant('browser') {
                                     events << "variant:" + sourceSet.name
                                 }
                                 layer('main') {
                                     events << "layer:" + sourceSet.name
                                 }
                                 unit('browser', 'main') {
                                     events << "unit:" + sourceSet.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(','))
                                     println("context=" + events.find { it.startsWith("context:" + browserMain.name + ":") })
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("browserMain=all,variant,layer,unit"));
                     assertTrue(result.getOutput().contains("browserTest=all,variant"));
                     assertTrue(result.getOutput().contains("nodeMain=all,layer"));
                     assertTrue(result.getOutput().contains("context=context:browserMain:browser:main"));
                 }
                 @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') {
                                         sourceSet {
                                             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 unitSourceSet = ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
                                         sourceSet {
                                             declareOutputs('late')
                                         }
                                     }
                                     unitSourceSet.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 unitSourceSet = ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
                                         sourceSet {
                                             declareOutputs('late')
                                         }
                                     }
                                     unitSourceSet.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') {
                                     sourceSet {
                                         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') {
                                     sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
                             }
                             """);
-                    assertBuildFails("Variant 'missing' isn't declared", "help");
+                    assertBuildFails("The specified 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) {
                                     sourceSet {
                                         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') {
                                     sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
                             }
                             """);
-                    assertBuildFails("Layer 'missing' isn't declared", "help");
+                    assertBuildFails("The specified 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) {
                                     sourceSet {
                                         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') {
                                     sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
                             }
                             """);
-                    assertBuildFails("The CompileUnit isn't declared for variant 'browser', layer 'test'", "help");
+                    assertBuildFails("Compile unit for variant 'browser' and layer 'test' not found", "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) {
                                     sourceSet {
                                         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");
                 }
             }

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