requireAllDefinedDependencies: Modules are not always on compile path

Fixes #47
Resolves #43

Author: jjohannes

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Extra Java Module Info Gradle Plugin - Changelog
 
 ## Version 1.4
+* [Fixed] [#47](https://github.com/gradlex-org/extra-java-module-info/issues/47) - requireAllDefinedDependencies() gives error when dependency only appears on runtime path (Thanks [Sola](https://github.com/unlimitedsola) for reporting!)
 * [Fixed] [#45](https://github.com/gradlex-org/extra-java-module-info/issues/45) - Sub-folders in 'META-INF/services' are not ignored (Thanks [Jonas Beyer](https://github.com/j-beyer) for reporting!)
 * [Fixed] [#44](https://github.com/gradlex-org/extra-java-module-info/issues/44) - Name resolution for jars with '-' character failing if Jars are taken from local .m2 repository (Thanks [Aidan Do](https://github.com/REslim30) for reporting!)
 

src/main/java/org/gradlex/javamodule/moduleinfo/ExtraJavaModuleInfoTransform.java

@@ -304,15 +304,21 @@ private byte[] addModuleInfo(ModuleInfo moduleInfo, Map<String, List<String>> pr
             Set<String> compileDependencies = getParameters().getCompileClasspathDependencies().get().get(moduleInfo.getIdentifier());
             Set<String> runtimeDependencies = getParameters().getRuntimeClasspathDependencies().get().get(moduleInfo.getIdentifier());
 
-            if (compileDependencies == null || runtimeDependencies  == null) {
+            if (compileDependencies == null && runtimeDependencies  == null) {
                 throw new RuntimeException("[requires directives from metadata] " +
                         "Cannot find dependencies for '" + moduleInfo.getModuleName() + "'. " +
                         "Are '" + moduleInfo.getIdentifier() + "' the correct component coordinates?");
             }
 
+            if (compileDependencies == null) {
+                compileDependencies = Collections.emptySet();
+            }
+            if (runtimeDependencies == null) {
+                runtimeDependencies = Collections.emptySet();
+            }
             Set<String> allDependencies = new TreeSet<>();
             allDependencies.addAll(compileDependencies);
-            allDependencies.addAll(runtimeDependencies );
+            allDependencies.addAll(runtimeDependencies);
             for (String ga: allDependencies) {
                 String moduleName = gaToModuleName(ga);
                 if (compileDependencies.contains(ga) && runtimeDependencies.contains(ga)) {

src/test/groovy/org/gradlex/javamodule/moduleinfo/test/RequireAllDefinedDependenciesFunctionalTest.groovy

@@ -78,6 +78,93 @@ class RequireAllDefinedDependenciesFunctionalTest extends Specification {
         run().task(':run').outcome == TaskOutcome.SUCCESS
     }
 
+    // See: https://github.com/gradlex-org/extra-java-module-info/issues/47
+    def "does not fail in case of runtime-only dependencies"() {
+        given:
+        file("src/main/java/org/gradle/sample/app/Main.java") << """
+            package org.gradle.sample.app;
+
+            public class Main {
+                public static void main(String[] args) throws Exception {
+                }
+            }
+        """
+        file("src/main/java/module-info.java") << """
+            module org.gradle.sample.app {
+                exports org.gradle.sample.app;
+                
+                requires kotlin.scripting.jvm.host;
+            }
+        """
+        buildFile << """          
+            dependencies {
+                implementation("org.jetbrains.kotlin:kotlin-scripting-jvm-host:1.8.20")
+            }
+            
+            tasks.register("resolveRuntimeClasspath") {
+                doLast { configurations.runtimeClasspath.get().resolve() }
+            }
+            
+            extraJavaModuleInfo {
+                knownModule("org.jetbrains.kotlin:kotlin-stdlib", "kotlin.stdlib")
+                knownModule("net.java.dev.jna:jna", "com.sun.jna")
+                module("org.jetbrains.kotlin:kotlin-stdlib-common", "kotlin.stdlib.common") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains:annotations", "org.jetbrains.annotations") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-reflect", "kotlin.reflect") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-scripting-jvm-host", "kotlin.scripting.jvm.host") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-script-runtime", "kotlin.script.runtime") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-scripting-common", "kotlin.scripting.common") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-scripting-jvm", "kotlin.scripting.jvm") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-compiler-embeddable", "kotlin.compiler.embeddable") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.intellij.deps:trove4j", "trove4j") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-daemon-embeddable", "kotlin.daemon.embeddable") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable", "kotlin.scripting.compiler.embeddable") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("org.jetbrains.kotlin:kotlin-scripting-compiler-impl-embeddable", "kotlin.scripting.compiler.impl.embeddable") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+            }
+        """
+
+        expect:
+        // The patched modules in this example do not run because of split-package and service provider issues
+        // run().task(':run').outcome == TaskOutcome.SUCCESS
+        runner('resolveRuntimeClasspath').build().task(':resolveRuntimeClasspath').outcome == TaskOutcome.SUCCESS
+    }
+
     def "can automatically add requires directives based on component metadata when module is only used in test"() {
         given:
         file("src/test/java/org/gradle/sample/app/test/AppTest.java") << """