Merge branch 'master' of https://github.com/java9-modularity/gradle-modules-plugin

siordache · siordache · commit 8a432519cfd0 · 2022-08-06T13:59:09.000+02:00
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -7,17 +7,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Git checkout
-      uses: actions/checkout@v2
-    - name: Configure Gradle cache
-      uses: actions/cache@v1
-      with:
-        path: ~/.gradle/caches
-        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
-        restore-keys: |
-          ${{ runner.os }}-gradle-
+      uses: actions/checkout@v3
     - name: Set up JDK 11
-      uses: actions/setup-java@v1
+      uses: actions/setup-java@v2
       with:
+        cache: gradle
+        distribution: microsoft
         java-version: 11
     - name: Build with Gradle
       run: ./gradlew build --scan
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
@@ -10,17 +10,12 @@ jobs:
       GRADLE_PUBLISH_SECRET: ${{ secrets.GRADLE_PUBLISH_SECRET }}
     steps:
     - name: Git checkout
-      uses: actions/checkout@v2
-    - name: Configure Gradle cache
-      uses: actions/cache@v1
-      with:
-        path: ~/.gradle/caches
-        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
-        restore-keys: |
-          ${{ runner.os }}-gradle-
+      uses: actions/checkout@v3
     - name: Set up JDK 11
-      uses: actions/setup-java@v1
+      uses: actions/setup-java@v2
       with:
+        cache: gradle
+        distribution: microsoft
         java-version: 11
     - name: Create gradle.properties
       run: echo -e "gradle.publish.key=$GRADLE_PUBLISH_KEY\ngradle.publish.secret=$GRADLE_PUBLISH_SECRET" > gradle.properties
diff --git a/src/main/java/org/javamodularity/moduleplugin/extensions/DefaultModularityExtension.java b/src/main/java/org/javamodularity/moduleplugin/extensions/DefaultModularityExtension.java
@@ -5,7 +5,10 @@
 import org.gradle.api.Project;
 import org.gradle.api.Task;
 import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.compile.JavaCompile;
+import org.gradle.jvm.toolchain.JavaToolchainSpec;
+import org.gradle.util.GradleVersion;
 import org.javamodularity.moduleplugin.JavaProjectHelper;
 import org.javamodularity.moduleplugin.tasks.ClasspathFile;
 
@@ -74,6 +77,17 @@ private void configureMixedJavaRelease(int mainJavaRelease, int moduleInfoJavaRe
     // TODO: Remove this method when Gradle supports it natively:  https://github.com/gradle/gradle/issues/2510
     private void setJavaRelease(JavaCompile javaCompile, int javaRelease) {
         String currentJavaVersion = JavaVersion.current().toString();
+        if (toolchainIsSupported()) {
+            JavaToolchainSpec toolchain = project.getExtensions().getByType(JavaPluginExtension.class).getToolchain();
+            if (toolchain != null) {
+                // If toolchain is enabled, the version of java compiler is NOT same to the version of JVM running Gradle
+                // so we need to get the version of toolchain explicitly as follows
+                String toolchainVersion = toolchain.getLanguageVersion().map(Object::toString).getOrNull();
+                if (toolchainVersion != null) {
+                    currentJavaVersion = toolchainVersion;
+                }
+            }
+        }
         if (!javaCompile.getSourceCompatibility().equals(currentJavaVersion)) {
             throw new IllegalStateException("sourceCompatibility should not be set together with --release option");
         }
@@ -86,8 +100,29 @@ private void setJavaRelease(JavaCompile javaCompile, int javaRelease) {
             throw new IllegalStateException("--release option is already set in compiler args");
         }
 
-        compilerArgs.add("--release");
-        compilerArgs.add(String.valueOf(javaRelease));
+        if (releaseOptionIsSupported()) {
+            // using the `convention(Integer)` method instead of the `set(Integer)` method, to let users set overwrite explicitly
+            javaCompile.getOptions().getRelease().convention(javaRelease);
+        } else {
+            compilerArgs.add("--release");
+            compilerArgs.add(String.valueOf(javaRelease));
+        }
+    }
+
+    /**
+     * @see <a href="https://github.com/gradle/gradle/issues/2510#issuecomment-657436188">The comment on GitHub issue that says {@code --release} option is added in Gradle 6.6</a>
+     * @return true if the version of Gradle is 6.6 or later
+     */
+    private boolean releaseOptionIsSupported() {
+        return GradleVersion.current().compareTo(GradleVersion.version("6.6")) >= 0;
+    }
+
+    /**
+     * @see <a href="https://docs.gradle.org/6.7/javadoc/org/gradle/api/plugins/JavaPluginExtension.html#getToolchain--">The Javadoc that says {@code JavaPluginExtension.getToolchain()} is added in Gradle 6.7</a>
+     * @return true if the version of Gradle is 6.7 or later
+     */
+    private boolean toolchainIsSupported() {
+        return GradleVersion.current().compareTo(GradleVersion.version("6.7")) >= 0;
     }
 
     private JavaProjectHelper helper() {
diff --git a/src/test/java/org/javamodularity/moduleplugin/ModulePluginSmokeTest.java b/src/test/java/org/javamodularity/moduleplugin/ModulePluginSmokeTest.java
@@ -6,8 +6,9 @@
 import org.gradle.api.logging.Logging;
 import org.gradle.testkit.runner.BuildResult;
 import org.gradle.testkit.runner.GradleRunner;
-import org.gradle.util.GradleVersion;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.CartesianEnumSource;
 import org.junitpioneer.jupiter.CartesianProductTest;
 import org.junitpioneer.jupiter.CartesianValueSource;
 
@@ -22,12 +23,35 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
+/**
+ * If you're locally seeing the error:
+ * {@code Could not create an instance of type org.gradle.initialization.DefaultSettings_Decorated.}
+ * when running these test it will because you're using a recent version of Java and running into:
+ * https://github.com/gradle/gradle/issues/10248.
+ *
+ * <p>Either switch to pre JDK-14 or <b>locally</b> comment out v5_1 and v5_2 in the {@link GradleVersion} enum.
+ */
 @SuppressWarnings("ConstantConditions")
 class ModulePluginSmokeTest {
     private static final Logger LOGGER = Logging.getLogger(ModulePluginSmokeTest.class);
 
     private List<File> pluginClasspath;
 
+    @SuppressWarnings("unused")
+    private enum GradleVersion {
+        // Locally comment out the 5.x versions if running JDK-14+
+        v5_1, v5_6,
+        v6_3, v6_4_1, v6_5_1, v6_8_3,
+        v7_0, v7_2
+        ;
+
+        @Override
+        public String toString() {
+            return  name().substring(1).replaceAll("_", ".");
+        }
+    }
+
+    @SuppressWarnings("UnstableApiUsage")
     @BeforeEach
     void before() throws IOException {
         pluginClasspath = Resources.readLines(Resources.getResource("plugin-classpath.txt"), Charsets.UTF_8)
@@ -38,38 +62,38 @@ void before() throws IOException {
 
     @CartesianProductTest(name = "smokeTest({arguments})")
     @CartesianValueSource(strings = {"test-project", "test-project-kotlin-pre-1-7", "test-project-kotlin", "test-project-groovy"})
-    @CartesianValueSource(strings = {"5.1", "5.6", "6.3", "6.4.1", "6.5.1", "6.8.3", "7.0", "7.2"})
-    void smokeTest(String projectName, String gradleVersion) {
+    @CartesianEnumSource(GradleVersion.class)
+    void smokeTest(String projectName, GradleVersion gradleVersion) {
         LOGGER.lifecycle("Executing smokeTest of {} with Gradle {}", projectName, gradleVersion);
         if(!checkCombination(projectName, gradleVersion)) return;
         var result = GradleRunner.create()
                 .withProjectDir(new File(projectName + "/"))
                 .withPluginClasspath(pluginClasspath)
-                .withGradleVersion(gradleVersion)
+                .withGradleVersion(gradleVersion.toString())
                 .withArguments("-c", "smoke_test_settings.gradle", "clean", "build", "run", "--stacktrace")
                 .forwardOutput()
                 .build();
 
         assertTasksSuccessful(result, "greeter.api", "build");
         assertTasksSuccessful(result, "greeter.provider", "build");
         assertTasksSuccessful(result, "greeter.provider.test", "build");
-        if(GradleVersion.version(gradleVersion).compareTo(GradleVersion.version("5.6")) >= 0) {
+        if(org.gradle.util.GradleVersion.version(gradleVersion.toString()).compareTo(org.gradle.util.GradleVersion.version("5.6")) >= 0) {
             assertTasksSuccessful(result, "greeter.provider.testfixture", "build");
         }
         assertTasksSuccessful(result, "greeter.runner", "build", "run");
     }
 
     @CartesianProductTest(name = "smokeTestRun({arguments})")
     @CartesianValueSource(strings = {"test-project", "test-project-kotlin-pre-1-7", "test-project-kotlin", "test-project-groovy"})
-    @CartesianValueSource(strings = {"5.1", "5.6", "6.3", "6.4.1", "6.5.1", "6.8.3", "7.0", "7.2"})
-    void smokeTestRun(String projectName, String gradleVersion) {
+    @CartesianEnumSource(GradleVersion.class)
+    void smokeTestRun(String projectName, GradleVersion gradleVersion) {
         LOGGER.lifecycle("Executing smokeTestRun of {} with Gradle {}", projectName, gradleVersion);
         if(!checkCombination(projectName, gradleVersion)) return;
         var writer = new StringWriter(256);
         var result = GradleRunner.create()
                 .withProjectDir(new File(projectName + "/"))
                 .withPluginClasspath(pluginClasspath)
-                .withGradleVersion(gradleVersion)
+                .withGradleVersion(gradleVersion.toString())
                 .withArguments("-q", "-c", "smoke_test_settings.gradle", "clean", ":greeter.runner:run", "--args", "aaa bbb")
                 .forwardStdOutput(writer)
                 .forwardStdError(writer)
@@ -83,19 +107,18 @@ void smokeTestRun(String projectName, String gradleVersion) {
         assertEquals("welcome", lines.get(2));
     }
 
-
     @CartesianProductTest(name = "smokeTestJunit5({arguments})")
     @CartesianValueSource(strings = {"5.4.2/1.4.2", "5.5.2/1.5.2", "5.7.1/1.7.1"})
-    @CartesianValueSource(strings = {"5.1", "5.6", "6.3", "6.4.1", "6.5.1", "6.8.3", "7.0", "7.2"})
-    void smokeTestJunit5(String junitVersionPair, String gradleVersion) {
+    @CartesianEnumSource(GradleVersion.class)
+    void smokeTestJunit5(String junitVersionPair, GradleVersion gradleVersion) {
         LOGGER.lifecycle("Executing smokeTestJunit5 with junitVersionPair {} and Gradle {}", junitVersionPair, gradleVersion);
         var junitVersionParts = junitVersionPair.split("/");
         var junitVersionProperty = String.format("-PjUnitVersion=%s", junitVersionParts[0]);
         var junitPlatformVersionProperty = String.format("-PjUnitPlatformVersion=%s", junitVersionParts[1]);
         var result = GradleRunner.create()
                 .withProjectDir(new File("test-project/"))
                 .withPluginClasspath(pluginClasspath)
-                .withGradleVersion(gradleVersion)
+                .withGradleVersion(gradleVersion.toString())
                 .withArguments("-c", "smoke_test_settings.gradle", junitVersionProperty, junitPlatformVersionProperty, "clean", "build", "run", "--stacktrace")
                 .forwardOutput()
                 .build();
@@ -107,13 +130,13 @@ void smokeTestJunit5(String junitVersionPair, String gradleVersion) {
     }
 
     @CartesianProductTest(name = "smokeTestMixed({arguments})")
-    @CartesianValueSource(strings = {"5.1", "5.6", "6.3", "6.4.1", "6.5.1", "6.8.3", "7.0", "7.2"})
-    void smokeTestMixed(String gradleVersion) {
+    @CartesianEnumSource(GradleVersion.class)
+    void smokeTestMixed(GradleVersion gradleVersion) {
         LOGGER.lifecycle("Executing smokeTestMixed with Gradle {}", gradleVersion);
         var result = GradleRunner.create()
                 .withProjectDir(new File("test-project-mixed"))
                 .withPluginClasspath(pluginClasspath)
-                .withGradleVersion(gradleVersion)
+                .withGradleVersion(gradleVersion.toString())
                 .withArguments("-c", "smoke_test_settings.gradle", "clean", "build", "--stacktrace")
                 .forwardOutput()
                 .build();
@@ -159,14 +182,14 @@ private static void assertExpectedClassFileFormats(
 
     @CartesianProductTest(name = "smokeTestDist({arguments})")
     @CartesianValueSource(strings = {"test-project", "test-project-kotlin-pre-1-7", "test-project-kotlin", "test-project-groovy"})
-    @CartesianValueSource(strings = {"5.1", "5.6", "6.3", "6.4.1", "6.5.1", "6.8.3", "7.0", "7.2"})
-    void smokeTestDist(String projectName, String gradleVersion) {
+    @CartesianEnumSource(GradleVersion.class)
+    void smokeTestDist(String projectName, GradleVersion gradleVersion) {
         LOGGER.lifecycle("Executing smokeTestDist of {} with Gradle {}", projectName, gradleVersion);
         if(!checkCombination(projectName, gradleVersion)) return;
         var result = GradleRunner.create()
                 .withProjectDir(new File(projectName + "/"))
                 .withPluginClasspath(pluginClasspath)
-                .withGradleVersion(gradleVersion)
+                .withGradleVersion(gradleVersion.toString())
                 .withArguments("-c", "smoke_test_settings.gradle", "clean", "build", ":greeter.runner:installDist", "--stacktrace")
                 .forwardOutput()
                 .build();
@@ -200,14 +223,14 @@ void smokeTestDist(String projectName, String gradleVersion) {
 
     @CartesianProductTest(name = "smokeTestRunDemo({arguments})")
     @CartesianValueSource(strings = {"test-project", "test-project-kotlin-pre-1-7", "test-project-kotlin", "test-project-groovy"})
-    @CartesianValueSource(strings = {"5.1", "5.6", "6.3", "6.4.1", "6.5.1", "6.8.3", "7.0", "7.2"})
-    void smokeTestRunDemo(String projectName, String gradleVersion) {
+    @CartesianEnumSource(GradleVersion.class)
+    void smokeTestRunDemo(String projectName, GradleVersion gradleVersion) {
         LOGGER.lifecycle("Executing smokeTestRunDemo of {} with Gradle {}", projectName, gradleVersion);
         if(!checkCombination(projectName, gradleVersion)) return;
         var result = GradleRunner.create()
                 .withProjectDir(new File(projectName + "/"))
                 .withPluginClasspath(pluginClasspath)
-                .withGradleVersion(gradleVersion)
+                .withGradleVersion(gradleVersion.toString())
                 .withArguments("-c", "smoke_test_settings.gradle", "clean", "build",
                         ":greeter.javaexec:runDemo1", ":greeter.javaexec:runDemo2", "--info", "--stacktrace")
                 .forwardOutput()
@@ -219,14 +242,14 @@ void smokeTestRunDemo(String projectName, String gradleVersion) {
 
     @CartesianProductTest(name = "smokeTestRunStartScripts({arguments})")
     @CartesianValueSource(strings = {"test-project", "test-project-kotlin-pre-1-7", "test-project-kotlin", "test-project-groovy"})
-    @CartesianValueSource(strings = {"5.1", "5.6", "6.3", "6.4.1", "6.5.1", "6.8.3", "7.0", "7.2"})
-    void smokeTestRunStartScripts(String projectName, String gradleVersion) {
+    @CartesianEnumSource(GradleVersion.class)
+    void smokeTestRunStartScripts(String projectName, GradleVersion gradleVersion) {
         LOGGER.lifecycle("Executing smokeTestRunScripts of {} with Gradle {}", projectName, gradleVersion);
         if(!checkCombination(projectName, gradleVersion)) return;
         var result = GradleRunner.create()
                 .withProjectDir(new File(projectName + "/"))
                 .withPluginClasspath(pluginClasspath)
-                .withGradleVersion(gradleVersion)
+                .withGradleVersion(gradleVersion.toString())
                 .withArguments("-c", "smoke_test_settings.gradle", "clean", ":greeter.startscripts:installDist", "--info", "--stacktrace")
                 .forwardOutput()
                 .build();
@@ -241,15 +264,20 @@ void smokeTestRunStartScripts(String projectName, String gradleVersion) {
         assertEquals("Demo2: welcome home, Alice and Bob!", ctx.getAppOutput("demo2"));
     }
 
+    @Test
+    void shouldNotCheckInWithCommentedOutVersions() {
+        assertEquals(8, GradleVersion.values().length);
+    }
+
     private static void assertTasksSuccessful(BuildResult result, String subprojectName, String... taskNames) {
         for (String taskName : taskNames) {
             SmokeTestHelper.assertTaskSuccessful(result, subprojectName, taskName);
         }
     }
 
-    private static boolean checkCombination(String projectName, String gradleVersion) {
-        final boolean kotlin_NotSupported = projectName.startsWith("test-project-kotlin") && gradleVersion.compareTo("6.4") < 0;
-        final boolean kotlin1_7_NotSupported = projectName.equals("test-project-kotlin") && gradleVersion.compareTo("6.6") < 0;
+    private static boolean checkCombination(String projectName, GradleVersion gradleVersion) {
+        final boolean kotlin_NotSupported = projectName.startsWith("test-project-kotlin") && gradleVersion.toString().compareTo("6.4") < 0;
+        final boolean kotlin1_7_NotSupported = projectName.equals("test-project-kotlin") && gradleVersion.toString().compareTo("6.6") < 0;
         if (kotlin_NotSupported || kotlin1_7_NotSupported) {
             LOGGER.lifecycle("Unsupported combination: {} / Gradle {}. Test skipped", projectName, gradleVersion);
             return false;
diff --git a/test-project/greeter.toolchain/build.gradle b/test-project/greeter.toolchain/build.gradle
@@ -0,0 +1,18 @@
+//region NO-OP (DSL testing)
+
+// one of the supported Java version (prefer LTS version)
+def toolchainVer = 11
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(toolchainVer))
+    }
+}
+
+modularity {
+    // This version should be less than `toolchainVer` because:
+    // * if the version is same to `toolchainVer` we cannot reproduce the existing problem
+    // * if the version is greather than `toolchainVer` javac cannot create class files
+    standardJavaRelease(9)
+}
+//endregion
diff --git a/test-project/greeter.toolchain/src/main/java/examples/greeter/api/Greeter.java b/test-project/greeter.toolchain/src/main/java/examples/greeter/api/Greeter.java
@@ -0,0 +1,5 @@
+package examples.greeter.api;
+
+public interface Greeter {
+    String hello();
+}
diff --git a/test-project/greeter.toolchain/src/main/java/module-info.java b/test-project/greeter.toolchain/src/main/java/module-info.java
@@ -0,0 +1,3 @@
+module greeter.api {
+    exports examples.greeter.api;
+}
diff --git a/test-project/settings.gradle b/test-project/settings.gradle
@@ -15,3 +15,7 @@ include 'greeter.runner'
 
 include 'greeter.javaexec'
 include 'greeter.startscripts'
+
+if(GradleVersion.current().compareTo(GradleVersion.version("6.6")) >= 0) {
+    include 'greeter.toolchain'
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+module greeter.api {`
	`2`	`+ exports examples.greeter.api;`
	`3`	`+}`