improved lombok plugin to support JPMS

gradle.properties

@@ -1,8 +1,8 @@
 woggioniMavenRepositoryUrl=https://mvn.woggioni.net/
 
-lys.catalog.version=2023.07.08
+lys.catalog.version=2023.07.16
 
-version.myGradlePlugins=2023.07.09
+version.myGradlePlugins=2023.07.16
 version.gradle=7.6
 version.felix.config.admin=1.9.26
 version.felix=7.0.5

lombok/src/main/java/net/woggioni/gradle/lombok/Delombok.java

@@ -1,8 +1,18 @@
 package net.woggioni.gradle.lombok;
 
-import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.file.SourceDirectorySet;
+import org.gradle.api.provider.Property;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.Internal;
 import org.gradle.api.tasks.JavaExec;
 import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.internal.jvm.JavaModuleDetector;
 
 import javax.inject.Inject;
 import java.io.File;
@@ -10,12 +20,10 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
-public class Delombok extends JavaExec {
+@RequiredArgsConstructor(onConstructor_ = {@Inject})
-
+public abstract class Delombok extends JavaExec {
-    @Getter
-    @OutputDirectory
-    private final File outputDir;
 
+    private final JavaModuleDetector javaModuleDetector;
     private static String buildClasspathString(Iterable<File> classpath) {
         StringBuilder sb = new StringBuilder();
         Iterator<File> it = classpath.iterator();
@@ -33,19 +41,56 @@ public class Delombok extends JavaExec {
         return sb.toString();
     }
 
-    @Inject
+    @InputFiles
-    public Delombok(File lombokJar, File outputDir, Iterable<File> sourceDirs, String classpath) {
+    public Provider<FileCollection> getSourceClasspath() {
-        this.outputDir = outputDir;
+        return getSourceSet()
-        classpath(lombokJar);
+                .map(SourceSet::getCompileClasspath);
+    }
+
+    @Internal
+    abstract public Property<SourceSet> getSourceSet();
+    @Internal
+    abstract public Property<Configuration> getLombokJar();
+    @Internal
+    abstract public Property<Boolean> getInferModulePath();
+    @OutputDirectory
+    abstract public RegularFileProperty getOutputDir();
+    @InputFiles
+    public Provider<FileCollection> getInputFiles() {
+        return getSourceSet()
+            .map(SourceSet::getAllSource)
+            .map(SourceDirectorySet::getSourceDirectories)
+            .zip(getLombokJar(), FileCollection::plus);
+    }
+
+
+    @Override
+    public void exec() {
+        classpath(getLombokJar());
         List<String> args = new ArrayList<>();
         args.add("delombok");
         args.add("-d");
-        args.add(outputDir.getPath());
+        args.add(getOutputDir().getAsFile().get().getPath());
-        args.add("-c");
+        SourceSet sourceSet = getSourceSet().get();
-        args.add(classpath);
+        Boolean inferModulePath = getInferModulePath().get();
-        for(File sourceDir : sourceDirs) args.add(sourceDir.getPath());
+        FileCollection classpath = javaModuleDetector.inferClasspath(inferModulePath, sourceSet.getCompileClasspath());
+        if(!classpath.isEmpty()) {
+            args.add("-c");
+            args.add(classpath.getAsPath());
+        }
+        if(inferModulePath) {
+            FileCollection modulepath = javaModuleDetector.inferModulePath(true, sourceSet.getCompileClasspath());
+            if(!modulepath.isEmpty()) {
+                args.add("--module-path");
+                args.add(modulepath.getAsPath());
+            }
+        }
+        for(File sourceDir : sourceSet.getJava().getSrcDirs()) {
+            args.add(sourceDir.getPath());
+        }
         Object[] argsArray = new String[args.size()];
         args.toArray(argsArray);
         args(argsArray);
+        super.exec();
     }
 }

lombok/src/main/java/net/woggioni/gradle/lombok/LombokExtension.java

@@ -1,13 +1,7 @@
 package net.woggioni.gradle.lombok;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
 import org.gradle.api.provider.Property;
 
-import javax.inject.Inject;
+abstract public class LombokExtension {
-
+    abstract public Property<String> getVersion();
-@RequiredArgsConstructor(onConstructor_ = { @Inject })
-public class LombokExtension {
-    @Getter
-    private final Property<String> version;
 }

lombok/src/main/java/net/woggioni/gradle/lombok/LombokPlugin.java

@@ -7,6 +7,7 @@ import org.gradle.api.Task;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.dsl.DependencyHandler;
 import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.plugins.ExtraPropertiesExtension;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.provider.Provider;
@@ -28,76 +29,71 @@ public class LombokPlugin implements Plugin<Project> {
     public void apply(Project project) {
         project.getPluginManager().apply(JavaPlugin.class);
         ObjectFactory objectFactory = project.getObjects();
-        LombokExtension ext = project.getExtensions()
+        LombokExtension ext = project.getExtensions().create("lombok", LombokExtension.class);
-                .create("lombok", LombokExtension.class,
+        ExtraPropertiesExtension epe = project.getExtensions().getExtraProperties();
-                        objectFactory.property(String.class)
+        if(epe.has("version.lombok")) {
-                            .convention(project.provider(
+            ext.getVersion().convention(
-                                    () -> (String) project.getExtensions().getExtraProperties().get("version.lombok")))
+                project.provider(() -> (String) epe.get("version.lombok"))
-                );
+            );
-        project.afterEvaluate(p -> {
+        }
-            SourceSetContainer sourceSetContainer = project.getExtensions().findByType(JavaPluginExtension.class).getSourceSets();
+        JavaPluginExtension javaPluginExtension = project.getExtensions().findByType(JavaPluginExtension.class);
-            Provider<Map<String, String>> dependencyNotationProvider = project.provider(() -> {
+        SourceSetContainer sourceSetContainer = javaPluginExtension.getSourceSets();
-                 Map<String, String> m = new HashMap<>();
+        Provider<Map<String, String>> dependencyNotationProvider = ext.getVersion().map((String version) -> {
-                 m.put("group", "org.projectlombok");
+             Map<String, String> m = new HashMap<>();
-                 m.put("name", "lombok");
+             m.put("group", "org.projectlombok");
-                 m.put("version", ext.getVersion().get());
+             m.put("name", "lombok");
-                 return Collections.unmodifiableMap(m);
+             m.put("version", version);
-            });
+             return Collections.unmodifiableMap(m);
-            Configuration lombokConfiguration = project.getConfigurations().create("lombok");
+        });
-            project.getDependencies().addProvider(
+        Configuration lombokConfiguration = project.getConfigurations().create("lombok");
-                    lombokConfiguration.getName(),
+        project.getDependencies().addProvider(
+                lombokConfiguration.getName(),
+                dependencyNotationProvider,
+                externalModuleDependency -> {
+                }
+        );
+        for (SourceSet ss : sourceSetContainer) {
+            DependencyHandler dependencyHandler = project.getDependencies();
+            dependencyHandler.addProvider(
+                    ss.getCompileOnlyConfigurationName(),
                     dependencyNotationProvider,
                     externalModuleDependency -> {
-                    }
-            );
-            for (SourceSet ss : sourceSetContainer) {
-                DependencyHandler dependencyHandler = project.getDependencies();
-                dependencyHandler.addProvider(
-                        ss.getCompileOnlyConfigurationName(),
-                        dependencyNotationProvider,
-                        externalModuleDependency -> {
-                        });
-                dependencyHandler.addProvider(
-                        ss.getAnnotationProcessorConfigurationName(),
-                        dependencyNotationProvider,
-                        externalModuleDependency -> {
-                        });
-                TaskContainer tasks = project.getTasks();
-                String javadocTaskName = ss.getJavadocTaskName();
-                Task javadocTask = tasks.findByName(javadocTaskName);
-                if(javadocTask != null) {
-                    String delombokTaskName = "delombok" + ss.getName().substring(0, 1).toUpperCase() + ss.getName().substring(1);
-                    File outputDir = new File(new File(project.getBuildDir(), "delombok"), ss.getName());
-                    Javadoc javadoc = (Javadoc) javadocTask;
-                    TaskProvider<Delombok> delombokTaskProvider = tasks.register(delombokTaskName,
-                            Delombok.class,
-                            lombokConfiguration.getSingleFile(),
-                            outputDir,
-                            ss.getJava().getSrcDirs(),
-                            ss.getCompileClasspath().getAsPath()
-                    );
-                    delombokTaskProvider.configure(delombokTask -> {
-                        delombokTask.getInputs().files(ss.getAllSource().getSourceDirectories());
                     });
-                    javadoc.setSource(outputDir);
+            dependencyHandler.addProvider(
-                    javadoc.getInputs().files(delombokTaskProvider);
+                    ss.getAnnotationProcessorConfigurationName(),
+                    dependencyNotationProvider,
+                    externalModuleDependency -> {
+                    });
+            TaskContainer tasks = project.getTasks();
+            String javadocTaskName = ss.getJavadocTaskName();
+            Task javadocTask = tasks.findByName(javadocTaskName);
+            if(javadocTask != null) {
+                String delombokTaskName = "delombok" + ss.getName().substring(0, 1).toUpperCase() + ss.getName().substring(1);
+                File outputDir = new File(new File(project.getBuildDir(), "delombok"), ss.getName());
+                Javadoc javadoc = (Javadoc) javadocTask;
+                TaskProvider<Delombok> delombokTaskProvider = tasks.register(delombokTaskName, Delombok.class, (delombok -> {
+                    delombok.getSourceSet().set(ss);
+                    delombok.getOutputDir().set(outputDir);
+                    delombok.getLombokJar().set(lombokConfiguration);
+                    delombok.getInferModulePath().set(javaPluginExtension.getModularity().getInferModulePath());
+                }));
+                javadoc.setSource(outputDir);
+                javadoc.getInputs().files(delombokTaskProvider);
+            }
+        }
+        JavaToolchainSpec toolchain = javaPluginExtension.getToolchain();
+        if(toolchain.getLanguageVersion().isPresent()) {
+            project.afterEvaluate((Project pro) -> {
+                if(toolchain.getLanguageVersion().get().asInt() >= 16) {
+                    pro.getTasks().withType(JavaCompile.class, t -> {
+                        t.getOptions().getForkOptions().getJvmArgs().add("--illegal-access=permit");
+                    });
                 }
-            }
+            });
-            JavaPluginExtension javaPluginExtension = project.getExtensions().findByType(JavaPluginExtension.class);
+        } else if(JavaVersion.current().compareTo(JavaVersion.VERSION_16) >= 0) {
-            JavaToolchainSpec toolchain = javaPluginExtension.getToolchain();
+            project.getTasks().withType(JavaCompile.class, t -> {
-            if(toolchain.getLanguageVersion().isPresent()) {
+                t.getOptions().getForkOptions().getJvmArgs().add("--illegal-access=permit");
-                project.afterEvaluate((Project pro) -> {
+            });
-                    if(toolchain.getLanguageVersion().get().asInt() >= 16) {
+        }
-                        pro.getTasks().withType(JavaCompile.class, t -> {
-                            t.getOptions().getForkOptions().getJvmArgs().add("--illegal-access=permit");
-                        });
-                    }
-                });
-            } else if(JavaVersion.current().compareTo(JavaVersion.VERSION_16) >= 0) {
-                project.getTasks().withType(JavaCompile.class, t -> {
-                    t.getOptions().getForkOptions().getJvmArgs().add("--illegal-access=permit");
-                });
-            }
-        });
     }
 }

settings.gradle

@@ -10,7 +10,6 @@ dependencyResolutionManagement {
     versionCatalogs {
         catalog {
             from group: 'com.lys', name: 'lys-catalog', version: getProperty('lys.catalog.version')
-            version("slf4j", "1.7.36")
         }
     }
 }