Introduce a new DSL method for omiting unwanted service providers

Fixes #13

Author: iherasymenko

README.md

@@ -84,3 +84,19 @@ configurations {
 ## How do I add `provides ... with ...` declarations to the `module-info.class` descriptor?
 
 The plugin will automatically retrofit all the available `META-INF/services/*` descriptors into `module-info.class` for you. The `META-INF/services/*` descriptors will be preserved so that a transformed JAR will continue to work if it is placed on the classpath.
+
+The plugin also allows you to ignore some unwanted services from being automatically converted into `provides .. with ...` declarations. 
+
+```
+extraJavaModuleInfo {               
+    module("groovy-all-2.4.15.jar", "groovy.all", "2.4.15") {
+       requiresTransitive("java.scripting")
+       requires("java.logging")
+       requires("java.desktop")
+       ignoreServiceProvider("org.codehaus.groovy.runtime.ExtensionModule")
+       ignoreServiceProvider("org.codehaus.groovy.plugins.Runners")
+       ignoreServiceProvider("org.codehaus.groovy.source.Extensions")
+       ignoreServiceProvider("org.codehaus.groovy.source.Extensions")
+    }
+}
+```

src/functionalTest/groovy/de/jjohannes/gradle/javamodules/test/ExtraJavaModuleInfoTest.groovy

@@ -357,6 +357,82 @@ class ExtraJavaModuleInfoTest extends Specification {
         run().task(':run').outcome == TaskOutcome.SUCCESS
     }
 
+    def "can omit unwanted META-INF/services from automatic migration"() {
+        given:
+        new File(testFolder.root, "src/main/java/org/gradle/sample/app/data").mkdirs()
+
+        testFolder.newFile("src/main/java/org/gradle/sample/app/Main.java") << """
+            package org.gradle.sample.app;
+            
+            import java.util.ServiceLoader;
+            import java.util.stream.Collectors;
+            import javax.script.ScriptEngineFactory;
+            import javax.script.ScriptException;
+            
+            public class Main {
+            
+                public static void main(String[] args) throws ScriptException {
+                    ScriptEngineFactory scriptEngineFactory = ServiceLoader.load(ScriptEngineFactory.class)
+                                        .findFirst()
+                                        .orElseThrow(() -> new AssertionError("No providers loaded"));
+                    String engineName = scriptEngineFactory.getEngineName();
+                    if (!engineName.equals("Groovy Scripting Engine")) {
+                        throw new AssertionError("Incorrect Script Engine Loaded: " + engineName);
+                    }
+                    int revVal = (int) scriptEngineFactory.getScriptEngine().eval("2+2");
+                    if (revVal != 4) {
+                        throw new AssertionError("Invalid evaluation result: " + revVal);
+                    }
+                }
+                          
+            }
+        """
+        testFolder.newFile("src/main/java/module-info.java") << """
+            module org.gradle.sample.app {               
+                requires groovy.all;
+                uses javax.script.ScriptEngineFactory;                                                           
+            }
+        """
+        testFolder.newFile("build.gradle.kts") << """
+            plugins {
+                application
+                id("de.jjohannes.extra-java-module-info")
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            java {
+                modularity.inferModulePath.set(true)
+            }
+            
+            dependencies {
+                implementation("org.codehaus.groovy:groovy-all:2.4.15")                     
+            }
+            
+            extraJavaModuleInfo {               
+                module("groovy-all-2.4.15.jar", "groovy.all", "2.4.15") {
+                   requiresTransitive("java.scripting")
+                   requires("java.logging")
+                   requires("java.desktop")
+                   ignoreServiceProvider("org.codehaus.groovy.runtime.ExtensionModule")
+                   ignoreServiceProvider("org.codehaus.groovy.plugins.Runners")
+                   ignoreServiceProvider("org.codehaus.groovy.source.Extensions")
+                   ignoreServiceProvider("org.codehaus.groovy.source.Extensions")
+                }
+            }
+             
+            application {
+                mainModule.set("org.gradle.sample.app")
+                mainClass.set("org.gradle.sample.app.Main")
+            }
+        """
+
+        expect:
+        run().task(':run').outcome == TaskOutcome.SUCCESS
+    }
+
     def "can add static/transitive 'requires' modifiers to legacy libraries"() {
         given:
         new File(testFolder.root, "src/main/java/org/gradle/sample/app/data").mkdirs()

src/main/java/de/jjohannes/gradle/javamodules/ExtraModuleInfoTransform.java

@@ -162,7 +162,7 @@ private static Map<String, String[]> copyAndExtractProviders(JarInputStream inpu
             byte[] content = inputStream.readAllBytes();
             String entryName = jarEntry.getName();
             if (entryName.startsWith(SERVICES_PREFIX) && !entryName.equals(SERVICES_PREFIX)) {
-                providers.put(entryName.substring(SERVICES_PREFIX.length()).replace('.','/'), extractImplementations(content));
+                providers.put(entryName.substring(SERVICES_PREFIX.length()), extractImplementations(content));
             }
             outputStream.putNextEntry(jarEntry);
             outputStream.write(content);
@@ -201,7 +201,11 @@ private static byte[] addModuleInfo(ModuleInfo moduleInfo, Map<String, String[]>
             moduleVisitor.visitRequire(requireName, Opcodes.ACC_STATIC_PHASE, null);
         }
         for (Map.Entry<String, String[]> entry : providers.entrySet()) {
-            moduleVisitor.visitProvide(entry.getKey(), entry.getValue());
+            String name = entry.getKey();
+            String[] implementations = entry.getValue();
+            if (!moduleInfo.getIgnoredServiceProviders().contains(name)) {
+                moduleVisitor.visitProvide(name.replace('.', '/'), implementations);
+            }
         }
         moduleVisitor.visitEnd();
         classWriter.visitEnd();

src/main/java/de/jjohannes/gradle/javamodules/ModuleInfo.java

@@ -17,7 +17,9 @@
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 
 /**
  * Data class to hold the information that should be added as module-info.class to an existing Jar file.
@@ -29,6 +31,7 @@ public class ModuleInfo implements Serializable {
     private List<String> requires = new ArrayList<>();
     private List<String> requiresTransitive = new ArrayList<>();
     private List<String> requiresStatic = new ArrayList<>();
+    private Set<String> ignoredServiceProviders = new LinkedHashSet<>();
 
     ModuleInfo(String moduleName, String moduleVersion) {
         this.moduleName = moduleName;
@@ -51,6 +54,10 @@ public void requiresStatic(String requiresStatic) {
         this.requiresStatic.add(requiresStatic);
     }
 
+    public void ignoreServiceProvider(String ignoreServiceProvider) {
+        this.ignoredServiceProviders.add(ignoreServiceProvider);
+    }
+
     public String getModuleName() {
         return moduleName;
     }
@@ -74,4 +81,9 @@ protected List<String> getRequiresTransitive() {
     protected List<String> getRequiresStatic() {
         return requiresStatic;
     }
+
+    protected Set<String> getIgnoredServiceProviders() {
+        return ignoredServiceProviders;
+    }
+
 }