Support 'group:name' notation and automatic version detection

jjohannes · jjohannes · commit 329293473e9b · 2022-05-02T18:06:26.000+02:00
The plugin is now able to identify a Jar by 'group:name' coordinates.
This information is used in the _merge Jar_ functionality to
automatically configure the 'javaModulesMergeJars' configuration
with all required dependencies.
The plugin can now also determine the version of the library to use
that version in the 'module-info.class'.

This all makes the DSL in 'extraJavaModuleInfo {}' significantly easier
to use.
diff --git a/README.md b/README.md
@@ -36,7 +36,7 @@ plugins {
 // add module information for all direct and transitive dependencies that are not modules
 extraJavaModuleInfo {
     // failOnMissingModuleInfo.set(false)
-    module("commons-beanutils-1.9.4.jar", "org.apache.commons.beanutils", "1.9.4") {
+    module("commons-beanutils:commons-beanutils", "org.apache.commons.beanutils") {
         exports("org.apache.commons.beanutils")
         
         requires("org.apache.commons.logging")
@@ -46,11 +46,11 @@ extraJavaModuleInfo {
         // requiresTransitive(...)
         // requiresStatic(...)
     }
-    module("commons-cli-1.4.jar", "org.apache.commons.cli", "3.2.2") {
+    module("commons-cli:commons-cli", "org.apache.commons.cli") {
         exports("org.apache.commons.cli")
     }
-    module("commons-collections-3.2.2.jar", "org.apache.commons.collections", "3.2.2")
-    automaticModule("commons-logging-1.2.jar", "org.apache.commons.logging")
+    module("commons-collections:commons-collections", "org.apache.commons.collections")
+    automaticModule("commons-logging:commons-logging", "org.apache.commons.logging")
 }
 ```
 
@@ -75,7 +75,7 @@ Sample uses Gradle's Kotlin DSL (`build.gradle.kts` file). The Groovy DSL syntax
 
 ## How do I deactivate the plugin functionality for a certain classpath?
 
-This is can be useful for the test classpath if it should be used for unit testing on the classpath (rather than the module path).
+This can be useful for the test classpath if it should be used for unit testing on the classpath (rather than the module path).
 If you use the [shadow plugin](https://plugins.gradle.org/plugin/com.github.johnrengelman.shadow) and [encounter this issue](https://github.com/jjohannes/extra-java-module-info/issues/7),
 you can deactivate it for the runtime classpath as the module information is irrelevant for a fat Jar in any case.
 
@@ -115,3 +115,24 @@ extraJavaModuleInfo {
     }
 }
 ```
+
+## What do I do in a 'split package' situation?
+
+The Java Module System does not allow the same package to be used in more than one _module_.
+This is an issue with legacy libraries, where it was common practice to use the same package in multiple Jars.
+This plugin offers the option to merge multiple Jars into one in such situations:
+
+```
+ extraJavaModuleInfo {
+    module("org.apache.zookeeper:zookeeper", "org.apache.zookeeper") {
+        mergeJar("org.apache.zookeeper:zookeeper-jute")
+        
+        // ...
+    }
+    automaticModule("org.slf4j:slf4j-api", "org.slf4j") {
+        mergeJar("org.slf4j:slf4j-ext")
+    }
+}
+```
+
+Note: The merged Jar will include the *first* appearance of duplicated files (like the `MANIFEST.MF`).
diff --git a/src/main/java/de/jjohannes/gradle/javamodules/ExtraModuleInfoPlugin.java b/src/main/java/de/jjohannes/gradle/javamodules/ExtraModuleInfoPlugin.java
@@ -1,15 +1,29 @@
 package de.jjohannes.gradle.javamodules;
 
+import org.gradle.api.NonNullApi;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
+import org.gradle.api.Transformer;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.component.ComponentIdentifier;
+import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
+import org.gradle.api.artifacts.result.ResolvedArtifactResult;
 import org.gradle.api.attributes.Attribute;
 import org.gradle.api.attributes.Category;
 import org.gradle.api.attributes.Usage;
+import org.gradle.api.file.Directory;
+import org.gradle.api.file.ProjectLayout;
+import org.gradle.api.file.RegularFile;
 import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.SourceSetContainer;
 import org.gradle.util.GradleVersion;
 
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
 /**
  * Entry point of the plugin.
  */
@@ -38,6 +52,18 @@ private void configureTransform(Project project, ExtraModuleInfoPluginExtension
             c.setCanBeResolved(true);
             c.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, project.getObjects().named(Usage.class, Usage.JAVA_RUNTIME));
             c.getAttributes().attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, Category.LIBRARY));
+
+            // Automatically add dependencies for Jars where we know the coordinates
+            // Note: User still needs to provide versions in through constraints/platforms or consistent resolution.
+            c.withDependencies(d -> extension.getModuleSpecs().get().values().stream().flatMap(m ->
+                    m.getMergedJars().stream()).filter(s -> s.contains(":")).forEach(s ->
+                    d.add(project.getDependencies().create(s))));
+
+            // Automatically get versions from the runtime classpath
+            if (GradleVersion.current().compareTo(GradleVersion.version("6.8")) >= 0) {
+                //noinspection UnstableApiUsage
+                c.shouldResolveConsistentlyWith(project.getConfigurations().getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME));
+            }
         });
 
         Attribute<String> artifactType = Attribute.of("artifactType", String.class);
@@ -62,10 +88,42 @@ private void configureTransform(Project project, ExtraModuleInfoPluginExtension
             t.parameters(p -> {
                 p.getModuleSpecs().set(extension.getModuleSpecs());
                 p.getFailOnMissingModuleInfo().set(extension.getFailOnMissingModuleInfo());
-                p.getMergeJars().from(javaModulesMergeJars);
+
+                // See: https://github.com/adammurdoch/dependency-graph-as-task-inputs/blob/main/plugins/src/main/java/TestPlugin.java
+                Provider<Set<ResolvedArtifactResult>> artifacts = project.provider(() -> javaModulesMergeJars.getIncoming().getArtifacts().getArtifacts());
+                p.getMergeJarIds().set(artifacts.map(new IdExtractor()));
+                p.getMergeJars().set(artifacts.map(new FileExtractor(project.getLayout())));
             });
             t.getFrom().attribute(artifactType, "jar").attribute(javaModule, false);
             t.getTo().attribute(artifactType, "jar").attribute(javaModule, true);
         });
     }
+
+    private static class IdExtractor implements Transformer<List<String>, Collection<ResolvedArtifactResult>> {
+        @Override
+        public List<String> transform(Collection<ResolvedArtifactResult> artifacts) {
+            return artifacts.stream().map(a -> {
+                ComponentIdentifier componentIdentifier = a.getId().getComponentIdentifier();
+                if (componentIdentifier instanceof ModuleComponentIdentifier) {
+                    return ((ModuleComponentIdentifier) componentIdentifier).getModuleIdentifier().toString();
+                } else {
+                    return componentIdentifier.getDisplayName();
+                }
+            }).collect(Collectors.toList());
+        }
+    }
+
+    private static class FileExtractor implements Transformer<List<RegularFile>, Collection<ResolvedArtifactResult>> {
+        private final ProjectLayout projectLayout;
+
+        public FileExtractor(ProjectLayout projectLayout) {
+            this.projectLayout = projectLayout;
+        }
+
+        @Override
+        public List<RegularFile> transform(Collection<ResolvedArtifactResult> artifacts) {
+            Directory projectDirectory = projectLayout.getProjectDirectory();
+            return artifacts.stream().map(a -> projectDirectory.file(a.getFile().getAbsolutePath())).collect(Collectors.toList());
+        }
+    }
 }
diff --git a/src/main/java/de/jjohannes/gradle/javamodules/ExtraModuleInfoTransform.java b/src/main/java/de/jjohannes/gradle/javamodules/ExtraModuleInfoTransform.java
@@ -1,12 +1,14 @@
 package de.jjohannes.gradle.javamodules;
 
+import org.gradle.api.NonNullApi;
 import org.gradle.api.artifacts.CacheableRule;
 import org.gradle.api.artifacts.transform.InputArtifact;
 import org.gradle.api.artifacts.transform.TransformAction;
 import org.gradle.api.artifacts.transform.TransformOutputs;
 import org.gradle.api.artifacts.transform.TransformParameters;
-import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.FileSystemLocation;
+import org.gradle.api.file.RegularFile;
+import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.MapProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.provider.Provider;
@@ -16,17 +18,25 @@
 import org.objectweb.asm.ModuleVisitor;
 import org.objectweb.asm.Opcodes;
 
-import javax.annotation.Nonnull;
-import java.io.*;
+import javax.annotation.Nullable;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
-import java.util.LinkedHashMap;
+import java.nio.file.Path;
 import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
-import java.util.jar.*;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
 import java.util.regex.Pattern;
-import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipException;
 
@@ -36,6 +46,7 @@
  * was defined for it. This way we make sure that all Jars are turned into modules.
  */
 @CacheableRule
+@NonNullApi
 abstract public class ExtraModuleInfoTransform implements TransformAction<ExtraModuleInfoTransform.Parameter> {
 
     private static final Pattern MODULE_INFO_CLASS_MRJAR_PATH = Pattern.compile("META-INF/versions/\\d+/module-info.class");
@@ -47,39 +58,90 @@ public interface Parameter extends TransformParameters {
         MapProperty<String, ModuleSpec> getModuleSpecs();
         @Input
         Property<Boolean> getFailOnMissingModuleInfo();
+        @Input
+        ListProperty<String> getMergeJarIds();
         @InputFiles
-        ConfigurableFileCollection getMergeJars();
+        ListProperty<RegularFile> getMergeJars();
     }
 
     @InputArtifact
     protected abstract Provider<FileSystemLocation> getInputArtifact();
 
     @Override
-    public void transform(@Nonnull TransformOutputs outputs) {
+    public void transform(TransformOutputs outputs) {
         Map<String, ModuleSpec> moduleSpecs = getParameters().getModuleSpecs().get();
         File originalJar = getInputArtifact().get().getAsFile();
-        String originalJarName = originalJar.getName();
 
-        if (moduleSpecs.containsKey(originalJarName) && moduleSpecs.get(originalJarName) instanceof ModuleInfo) {
-            addModuleDescriptor(originalJar, getModuleJar(outputs, originalJar), (ModuleInfo) moduleSpecs.get(originalJarName));
-        } else if (moduleSpecs.containsKey(originalJarName) && moduleSpecs.get(originalJarName) instanceof AutomaticModuleName) {
-            addAutomaticModuleName(originalJar, getModuleJar(outputs, originalJar), (AutomaticModuleName) moduleSpecs.get(originalJarName));
+        ModuleSpec moduleSpec = findModuleSpec(originalJar);
+
+        if (moduleSpec instanceof ModuleInfo) {
+            addModuleDescriptor(originalJar, getModuleJar(outputs, originalJar), (ModuleInfo) moduleSpec);
+        } else if (moduleSpec instanceof AutomaticModuleName) {
+            addAutomaticModuleName(originalJar, getModuleJar(outputs, originalJar), (AutomaticModuleName) moduleSpec);
         } else if (isModule(originalJar)) {
             outputs.file(originalJar);
         } else if (isAutoModule(originalJar)) {
             outputs.file(originalJar);
         } else if (!willBeMerged(originalJar, moduleSpecs.values())) { // No output if this Jar will be merged
             if (getParameters().getFailOnMissingModuleInfo().get()) {
-                throw new RuntimeException("Not a module and no mapping defined: " + originalJarName);
+                throw new RuntimeException("Not a module and no mapping defined: " + originalJar.getName());
             } else {
                 outputs.file(originalJar);
             }
         }
     }
 
+    @Nullable
+    private ModuleSpec findModuleSpec(File originalJar) {
+        Map<String, ModuleSpec> moduleSpecs = getParameters().getModuleSpecs().get();
+
+        String gaCoordinates = gaCoordinatesFromFilePath(originalJar.toPath());
+        String originalJarName = originalJar.getName();
+
+        if (moduleSpecs.containsKey(gaCoordinates)) {
+            return moduleSpecs.get(gaCoordinates);
+        }
+        if (moduleSpecs.containsKey(originalJarName)) {
+            return moduleSpecs.get(originalJarName);
+        }
+
+        return null;
+    }
+
     private boolean willBeMerged(File originalJar, Collection<ModuleSpec> modules) {
-        return modules.stream().anyMatch(module ->
-                module.getMergedJars().stream().anyMatch(toMerge -> toMerge.equals(originalJar.getName())));
+        return modules.stream().anyMatch(module -> module.getMergedJars().stream().anyMatch(toMerge ->
+                toMerge.equals(gaCoordinatesFromFilePath(originalJar.toPath())) || toMerge.equals(originalJar.getName())));
+    }
+
+    /**
+     * Attempts to parse 'group' and 'name' coordinates from a path like:
+     * .gradle/caches/modules-2/files-2.1/org.slf4j/slf4j-api/1.7.36/6c62681a2f655b49963a5983b8b0950a6120ae14/slf4j-api-1.7.36.jar
+     */
+    @Nullable
+    private String gaCoordinatesFromFilePath(Path path) {
+        String version = versionFromFilePath(path);
+        if (version == null) {
+            return null;
+        }
+
+        String group = path.getName(path.getNameCount() - 5).toString();
+        String name = path.getName(path.getNameCount() - 4).toString();
+
+        return group + ":" + name;
+    }
+
+    @Nullable
+    private String versionFromFilePath(Path path) {
+        if (path.getNameCount() < 5) {
+            return null;
+        }
+
+        String version = path.getName(path.getNameCount() - 3).toString();
+        if (!path.getFileName().toString().contains(version)) {
+            return null;
+        }
+
+        return version;
     }
 
     private boolean isModule(File jar) {
@@ -156,15 +218,15 @@ private void addModuleDescriptor(File originalJar, File moduleJar, ModuleInfo mo
                 Map<String, String[]> providers = copyAndExtractProviders(inputStream, outputStream);
                 mergeJars(moduleInfo, outputStream);
                 outputStream.putNextEntry(new JarEntry("module-info.class"));
-                outputStream.write(addModuleInfo(moduleInfo, providers));
+                outputStream.write(addModuleInfo(moduleInfo, providers, versionFromFilePath(originalJar.toPath())));
                 outputStream.closeEntry();
             }
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
     }
 
-    private static JarOutputStream newJarOutputStream(OutputStream out, Manifest manifest) throws IOException {
+    private static JarOutputStream newJarOutputStream(OutputStream out, @Nullable Manifest manifest) throws IOException {
         return manifest == null ? new JarOutputStream(out) : new JarOutputStream(out, manifest);
     }
 
@@ -199,10 +261,11 @@ private static String[] extractImplementations(byte[] content) {
                 .toArray(String[]::new);
     }
 
-    private static byte[] addModuleInfo(ModuleInfo moduleInfo, Map<String, String[]> providers) {
+    private byte[] addModuleInfo(ModuleInfo moduleInfo, Map<String, String[]> providers, @Nullable String version) {
         ClassWriter classWriter = new ClassWriter(0);
         classWriter.visit(Opcodes.V9, Opcodes.ACC_MODULE, "module-info", null, null, null);
-        ModuleVisitor moduleVisitor = classWriter.visitModule(moduleInfo.getModuleName(), Opcodes.ACC_OPEN, moduleInfo.moduleVersion);
+        String moduleVersion = moduleInfo.getModuleVersion() == null ? version : moduleInfo.getModuleVersion();
+        ModuleVisitor moduleVisitor = classWriter.visitModule(moduleInfo.getModuleName(), Opcodes.ACC_OPEN, moduleVersion);
         for (String packageName : moduleInfo.exports) {
             moduleVisitor.visitExport(packageName.replace('.', '/'), 0);
         }
@@ -229,14 +292,29 @@ private static byte[] addModuleInfo(ModuleInfo moduleInfo, Map<String, String[]>
     }
 
     private void mergeJars(ModuleSpec moduleSpec, JarOutputStream outputStream) throws IOException {
-        for (String mergeJar : moduleSpec.getMergedJars()) {
-            Optional<File> mergeJarFile = getParameters().getMergeJars().getFiles().stream().filter(f -> f.getName().equals(mergeJar)).findFirst();
-            if (mergeJarFile.isPresent()) {
-                try (JarInputStream toMergeInputStream = new JarInputStream(Files.newInputStream(mergeJarFile.get().toPath()))) {
+        RegularFile mergeJarFile = null;
+        for (String identifier : moduleSpec.getMergedJars()) {
+            List<String> ids = getParameters().getMergeJarIds().get();
+            List<RegularFile> jarFiles = getParameters().getMergeJars().get();
+            for (int i = 0; i < ids.size(); i++) {
+                // referenced by 'group:version'
+                if (ids.get(i).equals(identifier)) {
+                    mergeJarFile = jarFiles.get(i);
+                    break;
+                }
+                // referenced by 'jar file name'
+                if (jarFiles.get(i).getAsFile().getName().equals(identifier)) {
+                    mergeJarFile = jarFiles.get(i);
+                    break;
+                }
+            }
+
+            if (mergeJarFile != null) {
+                try (JarInputStream toMergeInputStream = new JarInputStream(Files.newInputStream(mergeJarFile.getAsFile().toPath()))) {
                     copyEntries(toMergeInputStream, outputStream);
                 }
             } else {
-                throw new RuntimeException("Jar not found: " + mergeJar);
+                throw new RuntimeException("Jar not found: " + identifier);
             }
         }
     }
