Gradle plugin

Author: Glavo

README.md

@@ -66,7 +66,7 @@ buildscript {
 Then you can create a task that compiles `module-info.java` like this:
 
 ```kotlin
-val compileModuleInfo = tasks.create<org.glavo.mic.tasks.CompileModuleInfo>("compileModuleInfo") {
+val compileModuleInfo = tasks.create<org.glavo.mic.plugin.tasks.CompileModuleInfo>("compileModuleInfo") {
     sourceFile.set(file("src/main/module-info.java"))
     targetFile.set(buildDir.resolve("classes/java/module-info/module-info.class"))
 

build.gradle.kts

@@ -1,95 +1,87 @@
 import java.util.Properties
 
 plugins {
-    id("java")
+    `java-library`
     id("com.github.johnrengelman.shadow") version "7.1.2"
     `maven-publish`
     signing
     id("io.github.gradle-nexus.publish-plugin") version "1.1.0"
 }
 
-loadMavenPublishProperties()
-
 allprojects {
     apply {
-        plugin("java")
-        plugin("maven-publish")
+        plugin("java-library")
+        plugin("com.github.johnrengelman.shadow")
     }
 
     group = "org.glavo"
-    version = "1.5"// + "-SNAPSHOT"
+    version = "2.0-RC1" + "-SNAPSHOT"
 
     repositories {
         mavenCentral()
     }
 
-    dependencies {
-        compileOnly(gradleApi())
+    tasks.compileJava {
+        sourceCompatibility = "1.8"
+        targetCompatibility = "1.8"
+    }
 
-        testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
-        testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1")
+    tasks.withType<Javadoc>().configureEach {
+        (options as StandardJavadocDocletOptions).also {
+            it.encoding("UTF-8")
+            it.addStringOption("link", "https://docs.oracle.com/en/java/javase/17/docs/api/")
+            it.addBooleanOption("html5", true)
+            it.addStringOption("Xdoclint:none", "-quiet")
+        }
     }
 
+    java {
+        withSourcesJar()
+        withJavadocJar()
+    }
 
-    tasks.compileJava {
-        sourceCompatibility = "1.8"
-        targetCompatibility = "1.8"
+    tasks.jar {
+        archiveClassifier.set("core")
     }
 
-    tasks.getByName<Test>("test") {
-        useJUnitPlatform()
+    tasks.shadowJar {
+        archiveClassifier.set("")
+
+        relocate("org.objectweb.asm", "org.glavo.mic.asm")
+        relocate("com.github.javaparser", "org.glavo.mic.javaparser")
+
+        minimize()
     }
 }
 
-description = "Compiler for module-info.java"
 
 dependencies {
     implementation("com.github.javaparser:javaparser-core:3.24.2")
-    // implementation("com.github.javaparser:javaparser-symbol-solver-core:3.24.2")
     implementation("org.ow2.asm:asm:9.3")
 }
 
-tasks.jar {
-    enabled = false
-    dependsOn(tasks.shadowJar)
-}
+loadMavenPublishProperties()
 
-tasks.shadowJar {
+description = "Compiler for module-info.java"
+
+tasks.jar {
     manifest {
         attributes(
             "Main-Class" to "org.glavo.mic.ModuleInfoCompiler"
         )
     }
-
-    archiveClassifier.set(null as String?)
-
-    relocate("org.objectweb.asm", "org.glavo.mic.asm")
-    relocate("com.github.javaparser", "org.glavo.mic.javaparser")
-
-    minimize()
-}
-
-java {
-    withSourcesJar()
-    // withJavadocJar()
-}
-
-tasks.create<Jar>("javadocJar") {
-    group = "build"
-    archiveClassifier.set("javadoc")
-}
-
-tasks.withType<GenerateModuleMetadata>().configureEach {
-    enabled = false
 }
 
 configure<PublishingExtension> {
     publications {
         create<MavenPublication>("maven") {
+
+            project.shadow.component(this)
+
             groupId = project.group.toString()
             version = project.version.toString()
             artifactId = project.name
-            artifact(tasks.shadowJar)
+            //artifact(tasks.shadowJar)
             artifact(tasks["sourcesJar"])
             artifact(tasks["javadocJar"])
 
@@ -142,6 +134,10 @@ nexusPublishing {
     }
 }
 
+tasks.withType<GenerateModuleMetadata> {
+    enabled = false
+}
+
 fun loadMavenPublishProperties() {
     var secretPropsFile = project.rootProject.file("gradle/maven-central-publish.properties")
     if (!secretPropsFile.exists()) {

gradle-plugin/build.gradle.kts

@@ -1,55 +1,32 @@
 plugins {
     `java-gradle-plugin`
-    `maven-publish`
-    id("com.github.johnrengelman.shadow") version "7.1.2"
-    id("com.gradle.plugin-publish") version "1.0.0-rc-1"
+    id("com.gradle.plugin-publish") version "0.18.0"
 }
 
 dependencies {
     compileOnly(gradleApi())
+
     implementation(rootProject)
 }
 
-tasks.jar {
-    enabled = false
-    dependsOn(tasks.shadowJar)
+configurations.named(JavaPlugin.API_CONFIGURATION_NAME) {
+    dependencies.remove(project.dependencies.gradleApi())
 }
 
-tasks.shadowJar {
-    archiveClassifier.set(null as String?)
-
-    relocate("org.objectweb.asm", "org.glavo.mic.plugin.asm")
-    relocate("com.github.javaparser", "org.glavo.mic.plugin.javaparser")
-    minimize()
+pluginBundle {
+    website = "https://github.com/Glavo/module-info-compiler"
+    vcsUrl = "https://github.com/Glavo/module-info-compiler.git"
+    tags = listOf("java", "modules", "jpms", "modularity")
 }
 
 gradlePlugin {
     plugins {
-        create("kala-retro8") {
-            id = "org.glavo.mic.plugin"
-            displayName = "ModuleInfo Compiler"
-            description = ""
-            implementationClass = "kala.plugins.retro8.Retro8Plugin"
+        create("compileModuleInfoPlugin") {
+            id = "org.glavo.compile-module-info"
+            displayName = "Compile Module Info Plugin"
+            description = rootProject.description
+            implementationClass = "org.glavo.mic.plugin.CompileModuleInfoPlugin"
         }
     }
 }
 
-pluginBundle {
-    website = "https://github.com/Glavo/kala-retro8"
-    vcsUrl = "https://github.com/Glavo/kala-retro8.git"
-    tags = listOf("java", "modules", "jpms", "modularity")
-}
-
-publishing {
-    repositories {
-        mavenLocal()
-    }
-
-    publications {
-        this.create<MavenPublication>("pluginMaven") {
-            groupId = project.group.toString()
-            artifactId = project.name
-            version = project.version.toString()
-        }
-    }
-}

gradle-plugin/src/main/java/org/glavo/mic/plugin/CompileModuleInfoPlugin.java

@@ -1,24 +1,62 @@
 package org.glavo.mic.plugin;
 
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.jvm.tasks.Jar;
+import org.glavo.mic.plugin.tasks.CompileModuleInfo;
+import org.gradle.api.*;
+import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.plugins.JavaPluginExtension;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.api.tasks.compile.JavaCompile;
+import org.gradle.util.GradleVersion;
 
-import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Optional;
 
 public class CompileModuleInfoPlugin implements Plugin<Project> {
     @Override
     public void apply(Project project) {
-        project.getPlugins().apply(JavaPlugin.class);
+        project.getPlugins().apply("java");
 
-        CompileModuleInfo compileModuleInfo = project.getTasks().create("compileModuleInfo", CompileModuleInfo.class, task -> {
-            task.getSourceFile().set(project.file("src/main/java/module-info.java"));
-            task.getTargetFile().set(new File(project.getBuildDir(), "module-info/module-info.class"));
-        });
+        SourceSet main;
+        try {
+            if (GradleVersion.current().compareTo(GradleVersion.version("7.1")) >= 0) {
+                JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
+                main = javaPluginExtension.getSourceSets().getByName(SourceSet.MAIN_SOURCE_SET_NAME);
+            } else {
+                JavaPluginConvention javaConvention = project.getConvention().getPlugin(JavaPluginConvention.class);
+                main = javaConvention.getSourceSets().getByName(SourceSet.MAIN_SOURCE_SET_NAME);
+            }
+        } catch (IllegalStateException | UnknownDomainObjectException e) {
+            throw new GradleException("Cannot obtain JavaPluginConvention", e);
+        }
 
-        Jar jarTask = (Jar) project.getTasks().getByName("jar");
-        jarTask.dependsOn(compileModuleInfo);
-        jarTask.from(compileModuleInfo.getTargetFile());
+        Optional<Path> moduleInfoJava = main.getAllJava()
+                .getSourceDirectories()
+                .getFiles()
+                .stream()
+                .map(sourceDir -> sourceDir.toPath().resolve("module-info.java"))
+                .filter(Files::exists)
+                .findAny();
+
+        if (moduleInfoJava.isPresent()) {
+            JavaCompile compileJava = (JavaCompile) project.getTasks().getByName("compileJava");
+            compileJava.getModularity().getInferModulePath().set(false);
+            compileJava.exclude("module-info.java");
+
+            Path path = moduleInfoJava.get();
+            Path outputDir = project.getBuildDir().toPath().resolve("classes").resolve("module-info").resolve("main");
+            main.getOutput().dir(outputDir);
+            //noinspection Convert2Lambda
+            TaskProvider<CompileModuleInfo> compileModuleInfo = project.getTasks().register("compileModuleInfo", CompileModuleInfo.class, new Action<CompileModuleInfo>() {
+                @Override
+                public void execute(CompileModuleInfo task) {
+                    task.getSourceFile().set(path.toFile());
+                    task.getTargetFile().set(outputDir.resolve("module-info.class").toFile());
+                }
+            });
+
+            project.getTasks().getByName("classes").dependsOn(compileModuleInfo);
+        }
     }
 }

src/main/java/org/glavo/mic/tasks/CompileModuleInfo.java renamed to gradle-plugin/src/main/java/org/glavo/mic/plugin/tasks/CompileModuleInfo.java

@@ -1,4 +1,4 @@
-package org.glavo.mic.tasks;
+package org.glavo.mic.plugin.tasks;
 
 import org.glavo.mic.ModuleInfoCompiler;
 import org.gradle.api.DefaultTask;

settings.gradle.kts

@@ -1,3 +1,3 @@
 rootProject.name = "module-info-compiler"
 
-// include("gradle-plugin")
+include("gradle-plugin")