Support registration of additional tasks for 'requires runtime' support

This is needed primarily for whitebox testing.

#20

Author: jjohannes

src/main/java/org/gradlex/javamodule/dependencies/JavaModuleDependenciesExtension.java

@@ -16,15 +16,29 @@
 
 package org.gradlex.javamodule.dependencies;
 
+import org.gradle.api.Task;
 import org.gradle.api.artifacts.VersionCatalog;
 import org.gradle.api.artifacts.VersionCatalogsExtension;
 import org.gradle.api.artifacts.VersionConstraint;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.Directory;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.ProjectLayout;
+import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.MapProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.compile.JavaCompile;
+import org.gradle.api.tasks.javadoc.Javadoc;
+import org.gradlex.javamodule.dependencies.internal.compile.AddSyntheticModulesToCompileClasspathAction;
+import org.gradlex.javamodule.dependencies.internal.utils.ModuleInfo;
+import org.gradlex.javamodule.dependencies.internal.utils.ModuleInfoCache;
 
 import javax.annotation.Nullable;
+import javax.inject.Inject;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
@@ -40,6 +54,7 @@ public abstract class JavaModuleDependenciesExtension {
     static final String JAVA_MODULE_DEPENDENCIES = "javaModuleDependencies";
 
     private final VersionCatalogsExtension versionCatalogs;
+    private final ModuleInfoCache moduleInfoCache;
 
     /**
      * @return the mappings from Module Name to GA coordinates; can be modified
@@ -70,6 +85,7 @@ public abstract class JavaModuleDependenciesExtension {
 
     public JavaModuleDependenciesExtension(VersionCatalogsExtension versionCatalogs) {
         this.versionCatalogs = versionCatalogs;
+        this.moduleInfoCache = getObjects().newInstance(ModuleInfoCache.class);
         getWarnForMissingVersions().convention(versionCatalogs != null);
         getVersionCatalogName().convention("libs");
         getModuleNameToGA().putAll(SharedMappings.mappings);
@@ -142,4 +158,48 @@ public String moduleName(String ga) {
         }
         return null;
     }
+
+    /**
+     * Adds support for compiling module-info.java in the given source set with the given task,
+     * if 'requires runtime' dependencies are used.
+     *
+     * @param task      The task that compiles code from the given source set
+     * @param sourceSet The source set that contains the module-info.java
+     */
+    public FileCollection addRequiresRuntimeSupport(JavaCompile task, SourceSet sourceSet) {
+        return doAddRequiresRuntimeSupport(task, sourceSet);
+    }
+
+    /**
+     * Adds support for generating Javadoc for the module-info.java in the given source set with the given task,
+     * if 'requires runtime' dependencies are used.
+     *
+     * @param task      The task that generates Javadoc from the given source set
+     * @param sourceSet The source set that contains the module-info.java
+     */
+    public FileCollection addRequiresRuntimeSupport(Javadoc task, SourceSet sourceSet) {
+        return doAddRequiresRuntimeSupport(task, sourceSet);
+    }
+
+    FileCollection doAddRequiresRuntimeSupport(Task task, SourceSet sourceSet) {
+        List<String> requiresRuntime = getModuleInfoCache().get(sourceSet).get(ModuleInfo.Directive.REQUIRES_RUNTIME);
+        ConfigurableFileCollection syntheticModuleInfoFolders = getObjects().fileCollection();
+        if (!requiresRuntime.isEmpty()) {
+            Provider<Directory> tmpDir = getLayout().getBuildDirectory().dir("tmp/java-module-dependencies/" + task.getName());
+            requiresRuntime.forEach(moduleName -> syntheticModuleInfoFolders.from(tmpDir.map(dir -> dir.dir(moduleName))));
+            task.doFirst(getObjects().newInstance(AddSyntheticModulesToCompileClasspathAction.class, syntheticModuleInfoFolders));
+            return syntheticModuleInfoFolders;
+        }
+        return syntheticModuleInfoFolders;
+    }
+
+    @Inject
+    protected abstract ObjectFactory getObjects();
+
+    @Inject
+    protected abstract ProjectLayout getLayout();
+
+    ModuleInfoCache getModuleInfoCache() {
+        return moduleInfoCache;
+    }
 }

src/main/java/org/gradlex/javamodule/dependencies/JavaModuleDependenciesPlugin.java

@@ -27,15 +27,13 @@
 import org.gradle.api.artifacts.VersionCatalog;
 import org.gradle.api.artifacts.VersionCatalogsExtension;
 import org.gradle.api.artifacts.VersionConstraint;
-import org.gradle.api.file.RegularFile;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.SourceSetContainer;
 import org.gradle.api.tasks.TaskProvider;
 import org.gradle.util.GradleVersion;
 import org.gradlex.javamodule.dependencies.internal.bridges.ExtraJavaModuleInfoBridge;
-import org.gradlex.javamodule.dependencies.internal.compile.AddSyntheticModulesToCompileClasspathAction;
 import org.gradlex.javamodule.dependencies.internal.utils.ModuleInfo;
 import org.gradlex.javamodule.dependencies.tasks.ModuleInfoGeneration;
 import org.gradlex.javamodule.dependencies.tasks.ModulePathAnalysis;
@@ -44,7 +42,6 @@
 import javax.annotation.Nullable;
 import java.io.File;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -63,8 +60,6 @@ public abstract class JavaModuleDependenciesPlugin implements Plugin<Project> {
 
     private static final String EXTRA_JAVA_MODULE_INFO_PLUGIN_ID = "org.gradlex.extra-java-module-info";
 
-    private final Map<File, ModuleInfo> moduleInfo = new HashMap<>();
-
     @Override
     public void apply(Project project) {
         if (GradleVersion.current().compareTo(GradleVersion.version("7.4")) < 0) {
@@ -91,12 +86,7 @@ private void setupForJavaProject(Project project, JavaModuleDependenciesExtensio
 
             project.getTasks().configureEach(task -> {
                 if (isJavaCompileTask(task, sourceSet) || isJavadocTask(task, sourceSet)) {
-                    List<String> requiresRuntime =
-                            findModuleInfoInSourceSet(sourceSet, project).get(ModuleInfo.Directive.REQUIRES_RUNTIME);
-                    if (!requiresRuntime.isEmpty()) {
-                        task.doFirst(project.getObjects().newInstance(AddSyntheticModulesToCompileClasspathAction.class,
-                                project.getLayout().getBuildDirectory().dir("tmp/java-module-dependencies/" + task.getName()).get().getAsFile(), requiresRuntime));
-                    }
+                    javaModuleDependencies.doAddRequiresRuntimeSupport(task, sourceSet);
                 }
             });
         });
@@ -176,31 +166,13 @@ private void process(ModuleInfo.Directive moduleDirective, String gradleConfigur
     }
 
     private void readModuleInfo(ModuleInfo.Directive moduleDirective, SourceSet sourceSet, Project project, Configuration configuration, JavaModuleDependenciesExtension javaModuleDependenciesExtension) {
-        ModuleInfo moduleInfo = findModuleInfoInSourceSet(sourceSet, project);
+        ModuleInfo moduleInfo = javaModuleDependenciesExtension.getModuleInfoCache().get(sourceSet);
         String ownModuleNamesPrefix = moduleInfo.moduleNamePrefix(project.getName(), sourceSet.getName());
         for (String moduleName : moduleInfo.get(moduleDirective)) {
             declareDependency(moduleName, ownModuleNamesPrefix, moduleInfo.getFilePath(), project, configuration, javaModuleDependenciesExtension);
         }
     }
 
-    /**
-     * Returns the module-info.java for the given SourceSet. If the SourceSet has multiple source folders with multiple
-     * module-info files (which is usually a broken setup) the first file found is returned.
-     */
-    private ModuleInfo findModuleInfoInSourceSet(SourceSet sourceSet, Project project) {
-        for (File folder : sourceSet.getJava().getSrcDirs()) {
-            Provider<RegularFile> moduleInfoFile = project.getLayout().file(project.provider(() -> new File(folder, "module-info.java")));
-            Provider<String> moduleInfoContent = project.getProviders().fileContents(moduleInfoFile).getAsText();
-            if (moduleInfoContent.isPresent()) {
-                if (!moduleInfo.containsKey(folder)) {
-                    moduleInfo.put(folder, new ModuleInfo(moduleInfoContent.get(), moduleInfoFile.get().getAsFile()));
-                }
-                return moduleInfo.get(folder);
-            }
-        }
-        return ModuleInfo.EMPTY;
-    }
-
     private void declareDependency(String moduleName, @Nullable String ownModuleNamesPrefix, File moduleInfoFile, Project project, Configuration configuration, JavaModuleDependenciesExtension javaModuleDependencies) {
         if (JDKInfo.MODULES.contains(moduleName)) {
             // The module is part of the JDK, no dependency required

src/main/java/org/gradlex/javamodule/dependencies/internal/compile/AddSyntheticModulesToCompileClasspathAction.java

@@ -19,41 +19,32 @@
 import org.gradle.api.Action;
 import org.gradle.api.NonNullApi;
 import org.gradle.api.Task;
-import org.gradle.api.file.ConfigurableFileCollection;
-import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.file.FileCollection;
 import org.gradle.api.tasks.compile.JavaCompile;
 import org.gradle.api.tasks.javadoc.Javadoc;
 import org.gradlex.javamodule.dependencies.internal.utils.ModuleInfoClassCreator;
 
 import javax.inject.Inject;
 import java.io.File;
-import java.util.List;
 
 @NonNullApi
 public abstract class AddSyntheticModulesToCompileClasspathAction implements Action<Task> {
 
-    private final File tmpFolder;
-    private final List<String> moduleDependencies;
-    private final ObjectFactory objects;
+    private final FileCollection syntheticModuleInfoFolders;
 
     @Inject
-    public AddSyntheticModulesToCompileClasspathAction(File tmpFolder, List<String> moduleDependencies, ObjectFactory objects) {
-        this.tmpFolder = tmpFolder;
-        this.moduleDependencies = moduleDependencies;
-        this.objects = objects;
+    public AddSyntheticModulesToCompileClasspathAction(FileCollection syntheticModuleInfoFolders) {
+        this.syntheticModuleInfoFolders = syntheticModuleInfoFolders;
     }
 
     @Override
     public void execute(Task task) {
-        if (moduleDependencies.isEmpty()) {
+        if (syntheticModuleInfoFolders.isEmpty()) {
             return;
         }
 
-        ConfigurableFileCollection syntheticModuleInfoFolders = objects.fileCollection();
-        for (String moduleName : moduleDependencies) {
-            File dir = new File(tmpFolder, moduleName + "-synthetic");
-            ModuleInfoClassCreator.createEmpty(moduleName, dir);
-            syntheticModuleInfoFolders.from(dir);
+        for (File moduleFolder : syntheticModuleInfoFolders) {
+            ModuleInfoClassCreator.createEmpty(moduleFolder);
         }
 
         if (task instanceof JavaCompile) {

src/main/java/org/gradlex/javamodule/dependencies/internal/utils/DependencyDeclarationsUtil.java

@@ -32,7 +32,7 @@
 import static org.gradle.api.attributes.Category.CATEGORY_ATTRIBUTE;
 import static org.gradle.api.attributes.Category.LIBRARY;
 
-public class DependencyDeclarationsUtil {
+public abstract class DependencyDeclarationsUtil {
 
     public static Provider<List<String>> declaredDependencies(Project project, String configuration) {
         ConfigurationContainer configurations = project.getConfigurations();

src/main/java/org/gradlex/javamodule/dependencies/internal/utils/ModuleInfoCache.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 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.internal.utils;
+
+import org.gradle.api.file.ProjectLayout;
+import org.gradle.api.file.RegularFile;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.provider.ProviderFactory;
+import org.gradle.api.tasks.SourceSet;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class ModuleInfoCache {
+
+    private final Map<File, ModuleInfo> moduleInfo = new HashMap<>();
+
+    @Inject
+    protected abstract ProviderFactory getProviders();
+
+    @Inject
+    protected abstract ProjectLayout getLayout();
+
+    /**
+     * Returns the module-info.java for the given SourceSet. If the SourceSet has multiple source folders with multiple
+     * module-info files (which is usually a broken setup) the first file found is returned.
+     */
+    public ModuleInfo get(SourceSet sourceSet) {
+        for (File folder : sourceSet.getJava().getSrcDirs()) {
+            Provider<RegularFile> moduleInfoFile = getLayout().file(getProviders().provider(() -> new File(folder, "module-info.java")));
+            Provider<String> moduleInfoContent = getProviders().fileContents(moduleInfoFile).getAsText();
+            if (moduleInfoContent.isPresent()) {
+                if (!moduleInfo.containsKey(folder)) {
+                    moduleInfo.put(folder, new ModuleInfo(moduleInfoContent.get(), moduleInfoFile.get().getAsFile()));
+                }
+                return moduleInfo.get(folder);
+            }
+        }
+        return ModuleInfo.EMPTY;
+    }
+}

src/main/java/org/gradlex/javamodule/dependencies/internal/utils/ModuleInfoClassCreator.java

@@ -27,15 +27,15 @@
 import static org.objectweb.asm.Opcodes.ACC_MODULE;
 import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
 
-public class ModuleInfoClassCreator {
+public abstract class ModuleInfoClassCreator {
 
-    public static void createEmpty(String moduleName, File targetFolder) {
+    public static void createEmpty(File targetFolder) {
         //noinspection ResultOfMethodCallIgnored
         targetFolder.mkdirs();
 
         ClassWriter cw = new ClassWriter(0);
         cw.visit(53, ACC_MODULE, "module-info", null, null, null);
-        ModuleVisitor moduleVisitor = cw.visitModule(moduleName, ACC_SYNTHETIC, null);
+        ModuleVisitor moduleVisitor = cw.visitModule(targetFolder.getName(), ACC_SYNTHETIC, null);
         moduleVisitor.visitRequire("java.base", ACC_MANDATED, null);
         cw.visitEnd();
         try (FileOutputStream s = new FileOutputStream(new File(targetFolder, "module-info.class"))) {

src/main/java/org/gradlex/javamodule/dependencies/internal/utils/ModuleNamingUtil.java

@@ -21,7 +21,7 @@
 import java.util.Arrays;
 import java.util.stream.Collectors;
 
-public class ModuleNamingUtil {
+public abstract class ModuleNamingUtil {
 
     public static String sourceSetToModuleName(String projectName, String sourceSetName) {
         if (sourceSetName.equals(SourceSet.MAIN_SOURCE_SET_NAME)) {

src/main/java/org/gradlex/javamodule/dependencies/internal/utils/TaskConfigurationUtil.java

@@ -1,11 +1,27 @@
+/*
+ * Copyright 2022 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.internal.utils;
 
 import org.gradle.api.Task;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.compile.JavaCompile;
 import org.gradle.api.tasks.javadoc.Javadoc;
 
-public class TaskConfigurationUtil {
+public abstract class TaskConfigurationUtil {
 
     public static boolean isJavaCompileTask(Task task, SourceSet sourceSet) {
         return task instanceof JavaCompile && task.getName().equals(sourceSet.getCompileJavaTaskName());

src/test/groovy/org/gradlex/javamodule/dependencies/test/RequiresRuntimeTest.groovy

@@ -148,4 +148,47 @@ class RequiresRuntimeTest extends Specification {
         then:
         result.task(':app:javadoc').outcome == TaskOutcome.SUCCESS
     }
+
+    def "can configure additional compile tasks to work with runtime only dependencies"() {
+        // This is typically needed for whitebox testing
+        given:
+        appBuildFile << '''
+            tasks.compileTestJava {
+                classpath += sourceSets.main.get().output
+                
+                val syntheticModules = javaModuleDependencies.addRequiresRuntimeSupport(this, sourceSets.main.get())
+                
+                options.compilerArgs.add("--module-path")
+                options.compilerArgs.add(classpath.files.joinToString(":") + ":" + syntheticModules.files.joinToString(":"))
+                options.compilerArgs.add("--patch-module")
+                options.compilerArgs.add("org.gradlex.test.app=" + sourceSets.test.get().java.sourceDirectories.first())
+                
+            }
+            
+            
+            dependencies.constraints {
+                javaModuleDependencies {
+                    implementation(gav("org.slf4j", "2.0.3"))
+                    implementation(gav("org.slf4j.simple", "2.0.3"))
+                }
+            }
+        '''
+        appModuleInfoFile << '''
+            module org.gradlex.test.app {
+                requires org.slf4j;
+                requires /*runtime*/ org.slf4j.simple;
+            }
+        '''
+        file("app/src/test/java/org/gradlex/test/app/MainTest.java") << """
+            package org.gradlex.test.app;
+            
+            public class MainTest {}
+        """
+
+        when:
+        def result = build()
+
+        then:
+        result.task(":app:compileTestJava").outcome == TaskOutcome.SUCCESS
+    }
 }