Support more classspaths when using 'requireAllDefinedDependencies()'

#40

Author: jjohannes

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

@@ -21,8 +21,10 @@
 import org.gradle.api.Project;
 import org.gradle.api.Transformer;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ConfigurationContainer;
 import org.gradle.api.artifacts.component.ComponentIdentifier;
 import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
+import org.gradle.api.artifacts.dsl.DependencyHandler;
 import org.gradle.api.artifacts.result.DependencyResult;
 import org.gradle.api.artifacts.result.ResolvedArtifactResult;
 import org.gradle.api.artifacts.result.ResolvedDependencyResult;
@@ -104,13 +106,15 @@ private void configureTransform(Project project, ExtraJavaModuleInfoPluginExtens
     }
 
     private void registerTransform(String fileExtension, Project project, ExtraJavaModuleInfoPluginExtension extension, Configuration javaModulesMergeJars, Attribute<String> artifactType, Attribute<Boolean> javaModule) {
+        DependencyHandler dependencies = project.getDependencies();
+        ConfigurationContainer configurations = project.getConfigurations();
+        SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
+
         // all Jars have a javaModule=false attribute by default; the transform also recognizes modules and returns them without modification
-        project.getDependencies().getArtifactTypes().maybeCreate(fileExtension).getAttributes().attribute(javaModule, false);
-        Configuration compileClasspath = project.getConfigurations().getByName(JavaPlugin.COMPILE_CLASSPATH_CONFIGURATION_NAME);
-        Configuration runtimeClasspath = project.getConfigurations().getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME);
+        dependencies.getArtifactTypes().maybeCreate(fileExtension).getAttributes().attribute(javaModule, false);
 
         // register the transform for Jars and "javaModule=false -> javaModule=true"; the plugin extension object fills the input parameter
-        project.getDependencies().registerTransform(ExtraJavaModuleInfoTransform.class, t -> {
+        dependencies.registerTransform(ExtraJavaModuleInfoTransform.class, t -> {
             t.parameters(p -> {
                 p.getModuleSpecs().set(extension.getModuleSpecs());
                 p.getFailOnMissingModuleInfo().set(extension.getFailOnMissingModuleInfo());
@@ -121,14 +125,16 @@ private void registerTransform(String fileExtension, Project project, ExtraJavaM
                 p.getMergeJarIds().set(artifacts.map(new IdExtractor()));
                 p.getMergeJars().set(artifacts.map(new FileExtractor(project.getLayout())));
                 p.getCompileClasspathDependencies().set(project.provider(() ->
-                        compileClasspath.getIncoming().getResolutionResult().getAllComponents().stream().collect(Collectors.toMap(
+                        sourceSets.stream().flatMap(s -> configurations.getByName(s.getCompileClasspathConfigurationName()).getIncoming().getResolutionResult().getAllComponents().stream()).collect(Collectors.toMap(
                                 c -> ga(c.getId()),
-                                c -> c.getDependencies().stream().map(ExtraJavaModuleInfoPlugin::ga).collect(Collectors.toSet())
+                                c -> c.getDependencies().stream().map(ExtraJavaModuleInfoPlugin::ga).collect(Collectors.toSet()),
+                                (dependencies1, dependencies2) -> dependencies1 // There can be duplications which are assumed to be the same
                 ))));
                 p.getRuntimeClasspathDependencies().set(project.provider(() ->
-                        runtimeClasspath.getIncoming().getResolutionResult().getAllComponents().stream().collect(Collectors.toMap(
+                        sourceSets.stream().flatMap(s -> configurations.getByName(s.getRuntimeClasspathConfigurationName()).getIncoming().getResolutionResult().getAllComponents().stream()).collect(Collectors.toMap(
                                 c -> ga(c.getId()),
-                                c -> c.getDependencies().stream().map(ExtraJavaModuleInfoPlugin::ga).collect(Collectors.toSet())
+                                c -> c.getDependencies().stream().map(ExtraJavaModuleInfoPlugin::ga).collect(Collectors.toSet()),
+                                (dependencies1, dependencies2) -> dependencies1 // There can be duplications which are assumed to be the same
                 ))));
             });
             t.getFrom().attribute(artifactType, fileExtension).attribute(javaModule, false);

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

@@ -35,7 +35,6 @@ class RequireAllDefinedDependenciesFunctionalTest extends Specification {
             import org.apache.http.client.methods.HttpPost;
             import org.apache.http.client.entity.UrlEncodedFormEntity;
             import org.apache.http.message.BasicNameValuePair;
-            
             import java.util.List;
             import java.util.ArrayList;
 
@@ -79,6 +78,62 @@ class RequireAllDefinedDependenciesFunctionalTest extends Specification {
         run().task(':run').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") << """
+            package org.gradle.sample.app.test;
+            
+            import org.apache.http.NameValuePair;
+            import org.apache.http.client.methods.HttpPost;
+            import org.apache.http.client.entity.UrlEncodedFormEntity;
+            import org.apache.http.message.BasicNameValuePair;
+            import org.junit.Test;
+            import java.util.List;
+            import java.util.ArrayList;
+
+            public class AppTest {
+                
+                @Test
+                public void testPost() throws Exception {
+                    HttpPost httpPost = new HttpPost("http://targethost/login");
+                    List<NameValuePair> nvps = new ArrayList<NameValuePair>();
+                    nvps.add(new BasicNameValuePair("username", "vip"));
+                    nvps.add(new BasicNameValuePair("password", "secret"));
+                    httpPost.setEntity(new UrlEncodedFormEntity(nvps));
+                }
+            }
+        """
+        file("src/test/java/module-info.java") << """
+            open module org.gradle.sample.app.test {
+                requires junit;
+                requires org.apache.httpcomponents.httpclient;
+            }
+        """
+        buildFile << """          
+            dependencies {
+                testImplementation("junit:junit:4.13.2")
+                testImplementation("org.apache.httpcomponents:httpclient:4.5.14")
+            }
+            
+            extraJavaModuleInfo {
+                automaticModule("org.hamcrest:hamcrest-core", "org.hamcrest.core")
+                module("${libs.commonsHttpClient}", "org.apache.httpcomponents.httpclient") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                module("${libs.commonsLogging}", "org.apache.commons.logging") {
+                    exportAllPackages()
+                    requireAllDefinedDependencies()
+                }
+                knownModule("commons-codec:commons-codec", "org.apache.commons.codec")
+                knownModule("org.apache.httpcomponents:httpcore", "org.apache.httpcomponents.httpcore")
+            }
+        """
+
+        expect:
+        test().task(':test').outcome == TaskOutcome.SUCCESS
+    }
+
     def "gives error if dependencies cannot be discovered"() {
         given:
         file("src/main/java/org/gradle/sample/app/Main.java") << """

src/test/groovy/org/gradlex/javamodule/moduleinfo/test/fixture/GradleBuild.groovy

@@ -34,6 +34,10 @@ class GradleBuild {
         runner('run').build()
     }
 
+    BuildResult test() {
+        runner('test').build()
+    }
+
     BuildResult fail() {
         runner('build').buildAndFail()
     }