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

                 "cSpell.words": [
                     "implab",
                     "materializer",
-                    "rawtypes"
+                    "rawtypes",
+                    "Replayable"
                 ]
             }

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

             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;
             /**
             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);
                 }
                     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());

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

             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) {
                     };
-                    extensions.add(VariantArtifactsExtension.class, "variantArtifacts", variantArtifacts);
+                    extensions.add(VariantArtifactsExtension.class, VARIANT_ARTIFACTS_EXTENSION, variantArtifacts);
                 }

variants/src/main/java/org/implab/gradle/variants/VariantSourcesPlugin.java +27 -38

             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.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;
             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();
                     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 roleProjections = RoleProjectionsView.of(variants);
                         // create registries
-                        var sourceSetRegistry = new SourceSetRegistry(objectFactory);
+                        var sourceSetRegistry = new SourceSetRegistry(objects);
                         lateConfigurationPolicy.finalizePolicy();
                         var sourceSetConfiguration = new SourceSetConfigurationRegistry(lateConfigurationPolicy::mode);
                                 .nameCollisionPolicy(namingPolicy.policy())
                                 .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,
                                 roleProjections,
                                 compileUnitNamer,
                                 sourceSetRegistry,
-                            sourceSetConfiguration
+                                sourceSetConfiguration);
-                        );
                         deferred.resolve(context);
                     });
                             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
                             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
                             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
                     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

              *
              */
             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());
                 }

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 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;
              * <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>
                 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;
                     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
                 }
                 /**
-                 * 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();

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

                                 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"));
                 }

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

                                 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)
                             }
                     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"));
                 }
                             }
                             """);
-                    assertBuildFails("Variant 'missing' isn't declared", "help");
+                    assertBuildFails("The specified variant 'missing' isn't declared", "help");
                 }
                 @Test
                             }
                             """);
-                    assertBuildFails("Layer 'missing' isn't declared", "help");
+                    assertBuildFails("The specified layer 'missing' isn't declared", "help");
                 }
                 @Test
                             }
                             """);
-                    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

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