Configuration action for 'versions' project

CHANGELOG.md

@@ -1,7 +1,8 @@
 # Java Module Dependencies Gradle Plugin - Changelog
 
-## Version 1.10.1
+## Version 1.11
 * [#245](https://github.com/gradlex-org/java-module-dependencies/issues/245) Add 'allLocalModules' access to extension
+* [#245](https://github.com/gradlex-org/java-module-dependencies/issues/247) Defining a 'versions' project in settings supports applying additional plugins
 * Update module name mappings
 
 ## Version 1.10

src/main/java/org/gradlex/javamodule/dependencies/initialization/JavaModulesExtension.java

@@ -38,7 +38,6 @@
 
 import javax.inject.Inject;
 import java.io.File;
-import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -74,7 +73,7 @@ public void module(String directory) {
     public void module(String directory, Action<Module> action) {
         Module module = getObjects().newInstance(Module.class, new File(settings.getRootDir(), directory));
         action.execute(module);
-        includeModule(module, new File(settings.getRootDir(), directory));
+        includeModule(module, new File(settings.getRootDir(), directory), false);
     }
 
     /**
@@ -92,7 +91,7 @@ public void module(ProjectDescriptor project, Action<Module> action) {
         module.getArtifact().set(project.getName());
         module.getArtifact().finalizeValue(); // finalize, as the project name can no longer be changed
         action.execute(module);
-        configureModule(module, project);
+        configureModule(module, project, false);
     }
 
     /**
@@ -111,7 +110,7 @@ public void directory(String directory, Action<Directory> action) {
         action.execute(moduleDirectory);
 
         for (Module module : moduleDirectory.customizedModules.values()) {
-            includeModule(module, module.directory);
+            includeModule(module, module.directory, false);
         }
         Provider<List<String>> listProvider = getProviders().of(ValueModuleDirectoryListing.class, spec -> {
             spec.getParameters().getExclusions().set(moduleDirectory.getExclusions());
@@ -124,7 +123,7 @@ public void directory(String directory, Action<Directory> action) {
             Module module = moduleDirectory.addModule(projectDir);
             if (!module.getModuleInfoPaths().get().isEmpty()) {
                 // only auto-include if there is at least one module-info.java
-                includeModule(module, new File(modulesDirectory, projectDir));
+                includeModule(module, new File(modulesDirectory, projectDir), false);
             }
         }
     }
@@ -133,47 +132,58 @@ public void directory(String directory, Action<Directory> action) {
      * Configure a subproject as Platform for defining Module versions.
      */
     public void versions(String directory) {
-        String projectName = Paths.get(directory).getFileName().toString();
-        settings.include(projectName);
-        settings.project(":" + projectName).setProjectDir(new File(settings.getRootDir(), directory));
-        settings.getGradle().getLifecycle().beforeProject(new ApplyJavaModuleVersionsPluginAction(":" + projectName));
+        versions(directory, m -> {});
     }
 
-    private void includeModule(Module module, File projectDir) {
+    /**
+     * Configure a subproject as Platform for defining Module versions.
+     */
+    public void versions(String directory, Action<Module> action) {
+        File versionProjectDir = new File(settings.getRootDir(), directory);
+        Module module = getObjects().newInstance(Module.class, versionProjectDir);
+        action.execute(module);
+        includeModule(module, module.directory, true);
+    }
+
+    private void includeModule(Module module, File projectDir, boolean definesVersions) {
         String artifact = module.getArtifact().get();
         settings.include(artifact);
         ProjectDescriptor project = settings.project(":" + artifact);
         project.setProjectDir(projectDir);
 
-        configureModule(module, project);
+        configureModule(module, project, definesVersions);
     }
 
-    private void configureModule(Module module, ProjectDescriptor project) {
+    private void configureModule(Module module, ProjectDescriptor project, boolean definesVersions) {
         String mainModuleName = null;
-        for (String moduleInfoPath : module.getModuleInfoPaths().get()) {
-            ModuleInfo moduleInfo = moduleInfoCache.put(project.getProjectDir(), moduleInfoPath,
-                    project.getPath(), module.getArtifact().get(), module.getGroup(), settings.getProviders());
-            if (moduleInfoPath.contains("/main/")) {
-                mainModuleName = moduleInfo.getModuleName();
+        if (!definesVersions) {
+            for (String moduleInfoPath : module.getModuleInfoPaths().get()) {
+                ModuleInfo moduleInfo = moduleInfoCache.put(project.getProjectDir(), moduleInfoPath,
+                        project.getPath(), module.getArtifact().get(), module.getGroup(), settings.getProviders());
+                if (moduleInfoPath.contains("/main/")) {
+                    mainModuleName = moduleInfo.getModuleName();
+                }
             }
         }
 
         String group = module.getGroup().getOrNull();
         List<String> plugins = module.getPlugins().get();
-        moduleProjects.add(new ModuleProject(project.getPath(), group, plugins, mainModuleName));
+        moduleProjects.add(new ModuleProject(project.getPath(), group, plugins, mainModuleName, definesVersions));
     }
 
     private static class ModuleProject {
         private final String path;
         private final @Nullable String group;
         private final List<String> plugins;
         private final @Nullable String mainModuleName;
+        private final boolean definesVersions;
 
-        public ModuleProject(String path, @Nullable String group, List<String> plugins, @Nullable String mainModuleName) {
+        public ModuleProject(String path, @Nullable String group, List<String> plugins, @Nullable String mainModuleName, boolean definesVersions) {
             this.path = path;
             this.group = group;
             this.plugins = plugins;
             this.mainModuleName = mainModuleName;
+            this.definesVersions = definesVersions;
         }
     }
 
@@ -192,8 +202,14 @@ public void execute(Project project) {
             for (ModuleProject m : moduleProjects) {
                 if (project.getPath().equals(m.path)) {
                     if (m.group != null) project.setGroup(m.group);
-                    project.getPlugins().apply(JavaModuleDependenciesPlugin.class);
-                    project.getExtensions().getByType(JavaModuleDependenciesExtension.class).getModuleInfoCache().set(moduleInfoCache);
+                    if (m.definesVersions) {
+                        project.getPlugins().apply(JavaPlatformPlugin.class);
+                        project.getPlugins().apply(JavaModuleVersionsPlugin.class);
+                        project.getExtensions().getByType(JavaPlatformExtension.class).allowDependencies();
+                    } else {
+                        project.getPlugins().apply(JavaModuleDependenciesPlugin.class);
+                        project.getExtensions().getByType(JavaModuleDependenciesExtension.class).getModuleInfoCache().set(moduleInfoCache);
+                    }
                     m.plugins.forEach(id -> project.getPlugins().apply(id));
                     if (m.mainModuleName != null) {
                         project.getPlugins().withType(ApplicationPlugin.class, p ->
@@ -203,22 +219,4 @@ public void execute(Project project) {
             }
         }
     }
-
-    private static class ApplyJavaModuleVersionsPluginAction implements IsolatedAction<Project> {
-
-        private final String projectPath;
-
-        public ApplyJavaModuleVersionsPluginAction(String projectPath) {
-            this.projectPath = projectPath;
-        }
-
-        @Override
-        public void execute(Project project) {
-            if (projectPath.equals(project.getPath())) {
-                project.getPlugins().apply(JavaPlatformPlugin.class);
-                project.getPlugins().apply(JavaModuleVersionsPlugin.class);
-                project.getExtensions().getByType(JavaPlatformExtension.class).allowDependencies();
-            }
-        }
-    }
 }

src/main/java/org/gradlex/javamodule/dependencies/initialization/Module.java

@@ -21,7 +21,6 @@
 
 import javax.inject.Inject;
 import java.io.File;
-import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

src/test/java/org/gradlex/javamodule/dependencies/test/initialization/SettingsPluginVersionManagementTest.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright the GradleX team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.gradlex.javamodule.dependencies.test.initialization;
+
+import org.gradlex.javamodule.dependencies.test.fixture.GradleBuild;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static java.util.Objects.requireNonNull;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.gradle.testkit.runner.TaskOutcome.SUCCESS;
+import static org.gradle.testkit.runner.TaskOutcome.UP_TO_DATE;
+
+class SettingsPluginVersionManagementTest {
+
+    GradleBuild build = new GradleBuild();
+
+    @BeforeEach
+    void setup() {
+        var buildFile = """
+            plugins { id("java-library") }
+            dependencies { implementation(platform(project(":versions"))) }""";
+        build.settingsFile.writeText("""
+            plugins { id("org.gradlex.java-module-dependencies") }
+            dependencyResolutionManagement { repositories.mavenCentral() }
+            """);
+        build.appBuildFile.writeText(buildFile);
+        build.libBuildFile.writeText(buildFile);
+    }
+
+    @Test
+    void can_define_a_version_providing_project_in_settings() {
+        build.settingsFile.appendText("""
+            javaModules {
+                directory(".")
+                versions("gradle/versions")
+            }""");
+        build.libModuleInfoFile.writeText("module abc.lib { }");
+        build.appModuleInfoFile.writeText("""
+            module org.gradlex.test.app {
+                requires abc.lib;
+                requires java.inject;
+            }""");
+        build.file("gradle/versions/build.gradle.kts").writeText("""
+                moduleInfo {
+                    version("java.inject", "1.0.5")
+                }""");
+
+        var result = build.runner(":app:compileJava").build();
+
+        assertThat(requireNonNull(result.task(":app:compileJava")).getOutcome()).isEqualTo(SUCCESS);
+    }
+
+    @Test
+    void can_define_a_version_providing_project_in_settings_with_additional_plugin() {
+        build.settingsFile.appendText("""
+            javaModules {
+                directory(".")
+                versions("gradle/versions") { plugin("maven-publish") }
+            }""");
+        build.libModuleInfoFile.writeText("module abc.lib { }");
+        build.appModuleInfoFile.writeText("""
+            module org.gradlex.test.app {
+                requires abc.lib;
+                requires java.inject;
+            }""");
+        build.file("gradle/versions/build.gradle.kts").writeText("""
+                moduleInfo {
+                    version("java.inject", "1.0.5")
+                }""");
+
+        var result = build.runner(":versions:publish").build();
+
+        assertThat(requireNonNull(result.task(":versions:publish")).getOutcome()).isEqualTo(UP_TO_DATE);
+    }
+
+}