Skip to content

Commit 150179c

Browse files
tlinkowskipaulbakker
tlinkowski
authored and
paulbakker
committedApr 4, 2019
#72: support for "moduleOptions.compileModuleInfoSeparately"
added CompileModuleOptions and CompileModuleInfoTask NOTE: potentially breaking change for "compileJava" in Kotlin DSL (see modified "build.gradle.kts")
·
v1.8.151.6.0
1 parent 83f15bf commit 150179c

File tree

11 files changed

+216
-26
lines changed

11 files changed

+216
-26
lines changed
 

‎README.md

+10
Original file line numberDiff line numberDiff line change
@@ -492,6 +492,16 @@ patchModules.config = [
492492
]
493493
```
494494

495+
Compilation
496+
===
497+
498+
Separate compilation of `module-info.java`
499+
----
500+
501+
If you need to compile the main `module-info.java` separately from the rest of `src/main/java`
502+
files, you can enable `compileModuleInfoSeparately` option on `compileJava` task. It will exclude `module-info.java`
503+
from `compileJava` and introduce a dedicated `compileModuleInfoJava` task.
504+
495505
Limitations
496506
===
497507

‎src/main/java/org/javamodularity/moduleplugin/ModuleSystemPlugin.java

+1
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ private void configureModularity(Project project, String moduleName) {
2020
extensions.create("patchModules", PatchModuleExtension.class);
2121

2222
new CompileTask(project).configureCompileJava();
23+
new CompileModuleInfoTask(project).configureCompileModuleInfoJava();
2324
new CompileTestTask().configureCompileTestJava(project, moduleName);
2425
new TestTask().configureTestJava(project, moduleName);
2526
new RunTask().configureRun(project, moduleName);

‎src/main/java/org/javamodularity/moduleplugin/extensions/CompileModuleOptions.java

+35
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
package org.javamodularity.moduleplugin.extensions;
2+
3+
import org.gradle.api.Project;
4+
import org.gradle.api.tasks.compile.JavaCompile;
5+
import org.javamodularity.moduleplugin.tasks.ModuleOptions;
6+
7+
public class CompileModuleOptions extends ModuleOptions {
8+
9+
/**
10+
* Name of the extra Java compile task created if {@code compileModuleInfoSeparately} is {@code true}.
11+
*/
12+
public static final String COMPILE_MODULE_INFO_TASK_NAME = "compileModuleInfoJava";
13+
14+
private final Project project;
15+
16+
private boolean compileModuleInfoSeparately = false;
17+
18+
public CompileModuleOptions(Project project) {
19+
super(project);
20+
this.project = project;
21+
}
22+
23+
public boolean getCompileModuleInfoSeparately() {
24+
return compileModuleInfoSeparately;
25+
}
26+
27+
public void setCompileModuleInfoSeparately(boolean compileModuleInfoSeparately) {
28+
if (compileModuleInfoSeparately) {
29+
// we need to create "compileModuleInfoJava" task eagerly so that the user can configure it immediately
30+
project.getTasks().maybeCreate(COMPILE_MODULE_INFO_TASK_NAME, JavaCompile.class);
31+
}
32+
this.compileModuleInfoSeparately = compileModuleInfoSeparately;
33+
}
34+
35+
}

‎src/main/java/org/javamodularity/moduleplugin/tasks/AbstractCompileTask.java

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
package org.javamodularity.moduleplugin.tasks;
2+
3+
import org.gradle.api.Project;
4+
import org.gradle.api.tasks.compile.JavaCompile;
5+
import org.javamodularity.moduleplugin.JavaProjectHelper;
6+
import org.javamodularity.moduleplugin.extensions.CompileModuleOptions;
7+
8+
abstract class AbstractCompileTask {
9+
10+
protected final Project project;
11+
12+
AbstractCompileTask(Project project) {
13+
this.project = project;
14+
}
15+
16+
final CompileJavaTaskMutator createCompileJavaTaskMutator(
17+
JavaCompile compileJava, CompileModuleOptions moduleOptions) {
18+
return new CompileJavaTaskMutator(project, compileJava.getClasspath(), moduleOptions);
19+
}
20+
21+
final JavaProjectHelper helper() {
22+
return new JavaProjectHelper(project);
23+
}
24+
}

‎src/main/java/org/javamodularity/moduleplugin/tasks/CompileJavaTaskMutator.java

+31-8
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,10 @@
11
package org.javamodularity.moduleplugin.tasks;
22

33
import org.gradle.api.Project;
4+
import org.gradle.api.file.FileCollection;
45
import org.gradle.api.tasks.compile.AbstractCompile;
56
import org.gradle.api.tasks.compile.JavaCompile;
7+
import org.javamodularity.moduleplugin.extensions.CompileModuleOptions;
68

79
import java.util.ArrayList;
810
import java.util.List;
@@ -11,27 +13,48 @@ class CompileJavaTaskMutator {
1113

1214
private static final String COMPILE_KOTLIN_TASK_NAME = "compileKotlin";
1315

14-
static void mutateJavaCompileTask(Project project, JavaCompile compileJava) {
15-
ModuleOptions moduleOptions = compileJava.getExtensions().getByType(ModuleOptions.class);
16+
private final Project project;
17+
/**
18+
* {@linkplain JavaCompile#getClasspath() Classpath} of {@code compileJava} task.
19+
*/
20+
private final FileCollection compileJavaClasspath;
21+
/**
22+
* {@link CompileModuleOptions} of {@code compileJava} task.
23+
*/
24+
private final CompileModuleOptions moduleOptions;
25+
26+
CompileJavaTaskMutator(Project project, FileCollection compileJavaClasspath, CompileModuleOptions moduleOptions) {
27+
this.project = project;
28+
this.compileJavaClasspath = compileJavaClasspath;
29+
this.moduleOptions = moduleOptions;
30+
}
31+
32+
/**
33+
* The argument is a {@link JavaCompile} task whose modularity is to be configured.
34+
*
35+
* @param javaCompile {@code compileJava} if {@link CompileModuleOptions#getCompileModuleInfoSeparately()}
36+
* is {@code false}, {@code compileModuleInfoJava} if it is {@code true}
37+
*/
38+
void modularizeJavaCompileTask(JavaCompile javaCompile) {
1639
PatchModuleExtension patchModuleExtension = project.getExtensions().getByType(PatchModuleExtension.class);
1740

18-
var compilerArgs = new ArrayList<>(compileJava.getOptions().getCompilerArgs());
41+
var compilerArgs = new ArrayList<>(javaCompile.getOptions().getCompilerArgs());
1942

20-
compilerArgs.addAll(List.of("--module-path", compileJava.getClasspath()
43+
compilerArgs.addAll(List.of("--module-path", compileJavaClasspath
2144
.filter(patchModuleExtension::isUnpatched)
2245
.getAsPath()));
2346

2447
String moduleName = (String) project.getExtensions().findByName("moduleName");
2548
moduleOptions.mutateArgs(moduleName, compilerArgs);
2649

27-
compilerArgs.addAll(patchModuleExtension.configure(compileJava.getClasspath()));
28-
compileJava.getOptions().setCompilerArgs(compilerArgs);
29-
compileJava.setClasspath(project.files());
50+
compilerArgs.addAll(patchModuleExtension.configure(compileJavaClasspath));
51+
javaCompile.getOptions().setCompilerArgs(compilerArgs);
52+
javaCompile.setClasspath(project.files());
3053

3154
// https://github.com/java9-modularity/gradle-modules-plugin/issues/45
3255
AbstractCompile compileKotlin = (AbstractCompile) project.getTasks().findByName(COMPILE_KOTLIN_TASK_NAME);
3356
if (compileKotlin != null) {
34-
compileJava.setDestinationDir(compileKotlin.getDestinationDir());
57+
javaCompile.setDestinationDir(compileKotlin.getDestinationDir());
3558
}
3659
}
3760

‎src/main/java/org/javamodularity/moduleplugin/tasks/CompileModuleInfoTask.java

+81
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
package org.javamodularity.moduleplugin.tasks;
2+
3+
import org.gradle.api.Action;
4+
import org.gradle.api.Project;
5+
import org.gradle.api.Task;
6+
import org.gradle.api.plugins.JavaPlugin;
7+
import org.gradle.api.tasks.compile.JavaCompile;
8+
import org.javamodularity.moduleplugin.extensions.CompileModuleOptions;
9+
10+
import java.nio.file.Files;
11+
import java.nio.file.Path;
12+
13+
public class CompileModuleInfoTask extends AbstractCompileTask {
14+
15+
public CompileModuleInfoTask(Project project) {
16+
super(project);
17+
}
18+
19+
/**
20+
* @see CompileTask#configureCompileJava()
21+
*/
22+
public void configureCompileModuleInfoJava() {
23+
helper().findCompileJavaTask(JavaPlugin.COMPILE_JAVA_TASK_NAME)
24+
.ifPresent(this::configureCompileModuleInfoJava);
25+
}
26+
27+
private void configureCompileModuleInfoJava(JavaCompile compileJava) {
28+
var moduleOptions = compileJava.getExtensions().getByType(CompileModuleOptions.class);
29+
project.afterEvaluate(p -> {
30+
if (moduleOptions.getCompileModuleInfoSeparately()) {
31+
configureModularityForCompileModuleInfoJava(compileJava, moduleOptions);
32+
}
33+
});
34+
}
35+
36+
/**
37+
* @see CompileTask#configureModularityForCompileJava
38+
*/
39+
void configureModularityForCompileModuleInfoJava(
40+
JavaCompile compileJava, CompileModuleOptions moduleOptions) {
41+
JavaCompile compileModuleInfoJava = preconfigureCompileModuleInfoJava(compileJava);
42+
CompileJavaTaskMutator mutator = createCompileJavaTaskMutator(compileJava, moduleOptions);
43+
44+
// don't convert to lambda: https://github.com/java9-modularity/gradle-modules-plugin/issues/54
45+
compileModuleInfoJava.doFirst(new Action<Task>() {
46+
@Override
47+
public void execute(Task task) {
48+
mutator.modularizeJavaCompileTask(compileModuleInfoJava);
49+
}
50+
});
51+
}
52+
53+
/**
54+
* Preconfigures a separate task that is meant to compile {@code module-info.java} separately.
55+
* Final (modular) configuration is performed later by {@link CompileJavaTaskMutator}.
56+
*/
57+
private JavaCompile preconfigureCompileModuleInfoJava(JavaCompile compileJava) {
58+
var compileModuleInfoJava = helper().compileJavaTask(CompileModuleOptions.COMPILE_MODULE_INFO_TASK_NAME);
59+
60+
compileModuleInfoJava.setClasspath(project.files()); // empty
61+
compileModuleInfoJava.setSource(pathToModuleInfoJava());
62+
compileModuleInfoJava.setDestinationDir(compileJava.getDestinationDir());
63+
64+
// we need all the compiled classes before compiling module-info.java
65+
compileModuleInfoJava.dependsOn(compileJava);
66+
67+
// make "classes" trigger module-info.java compilation
68+
helper().task(JavaPlugin.CLASSES_TASK_NAME).dependsOn(compileModuleInfoJava);
69+
70+
return compileModuleInfoJava;
71+
}
72+
73+
private Path pathToModuleInfoJava() {
74+
return helper().mainSourceSet().getJava().getSrcDirs().stream()
75+
.map(srcDir -> srcDir.toPath().resolve("module-info.java"))
76+
.filter(Files::exists)
77+
.findFirst()
78+
.orElseThrow(() -> new IllegalStateException("module-info.java not found"));
79+
}
80+
81+
}

‎src/main/java/org/javamodularity/moduleplugin/tasks/CompileTask.java

+21-10
Original file line numberDiff line numberDiff line change
@@ -5,34 +5,45 @@
55
import org.gradle.api.Task;
66
import org.gradle.api.plugins.JavaPlugin;
77
import org.gradle.api.tasks.compile.JavaCompile;
8-
import org.javamodularity.moduleplugin.JavaProjectHelper;
8+
import org.javamodularity.moduleplugin.extensions.CompileModuleOptions;
99

10-
public class CompileTask {
11-
12-
private final Project project;
10+
public class CompileTask extends AbstractCompileTask {
1311

1412
public CompileTask(Project project) {
15-
this.project = project;
13+
super(project);
1614
}
1715

16+
/**
17+
* @see CompileModuleInfoTask#configureCompileModuleInfoJava()
18+
*/
1819
public void configureCompileJava() {
1920
helper().findCompileJavaTask(JavaPlugin.COMPILE_JAVA_TASK_NAME)
2021
.ifPresent(this::configureCompileJava);
2122
}
2223

2324
private void configureCompileJava(JavaCompile compileJava) {
24-
compileJava.getExtensions().create("moduleOptions", ModuleOptions.class, project);
25+
var moduleOptions = compileJava.getExtensions().create("moduleOptions", CompileModuleOptions.class, project);
26+
project.afterEvaluate(p -> {
27+
if (moduleOptions.getCompileModuleInfoSeparately()) {
28+
compileJava.exclude("module-info.java");
29+
} else {
30+
configureModularityForCompileJava(compileJava, moduleOptions);
31+
}
32+
});
33+
}
2534

35+
/**
36+
* @see CompileModuleInfoTask#configureModularityForCompileModuleInfoJava
37+
*/
38+
void configureModularityForCompileJava(JavaCompile compileJava, CompileModuleOptions moduleOptions) {
39+
CompileJavaTaskMutator mutator = createCompileJavaTaskMutator(compileJava, moduleOptions);
2640
// don't convert to lambda: https://github.com/java9-modularity/gradle-modules-plugin/issues/54
2741
compileJava.doFirst(new Action<Task>() {
2842
@Override
2943
public void execute(Task task) {
30-
CompileJavaTaskMutator.mutateJavaCompileTask(project, compileJava);
44+
mutator.modularizeJavaCompileTask(compileJava);
3145
}
3246
});
3347
}
3448

35-
private JavaProjectHelper helper() {
36-
return new JavaProjectHelper(project);
37-
}
3849
}

‎src/main/java/org/javamodularity/moduleplugin/tasks/ModuleOptions.java

+1-1
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ public void setAddOpens(Map<String, String> addOpens) {
5252
this.addOpens = addOpens;
5353
}
5454

55-
void mutateArgs(String moduleName, List<String> args) {
55+
protected void mutateArgs(String moduleName, List<String> args) {
5656
if (!getAddModules().isEmpty()) {
5757
String addModules = String.join(",", getAddModules());
5858
args.add("--add-modules");

‎src/test/java/org/javamodularity/moduleplugin/tasks/CompileJavaTaskMutatorTest.java

+8-5
Original file line numberDiff line numberDiff line change
@@ -4,27 +4,30 @@
44
import org.gradle.api.plugins.JavaPlugin;
55
import org.gradle.api.tasks.compile.JavaCompile;
66
import org.gradle.testfixtures.ProjectBuilder;
7+
import org.javamodularity.moduleplugin.extensions.CompileModuleOptions;
78
import org.junit.jupiter.api.Test;
89

910
import java.io.File;
1011
import java.util.Arrays;
1112
import java.util.List;
1213

13-
import static org.junit.jupiter.api.Assertions.*;
14+
import static org.junit.jupiter.api.Assertions.assertEquals;
1415

1516
class CompileJavaTaskMutatorTest {
1617

1718
@Test
18-
void mutateJavaCompileTask() {
19+
void modularizeJavaCompileTask() {
1920
// given
2021
Project project = ProjectBuilder.builder().withProjectDir(new File("test-project/")).build();
2122
project.getPlugins().apply("java");
22-
final JavaCompile compileJava = (JavaCompile) project.getTasks().findByName(JavaPlugin.COMPILE_JAVA_TASK_NAME);
23-
compileJava.getExtensions().create("moduleOptions", ModuleOptions.class, project);
23+
JavaCompile compileJava = (JavaCompile) project.getTasks().getByName(JavaPlugin.COMPILE_JAVA_TASK_NAME);
24+
CompileModuleOptions moduleOptions = compileJava.getExtensions()
25+
.create("moduleOptions", CompileModuleOptions.class, project);
2426
project.getExtensions().create("patchModules", PatchModuleExtension.class);
27+
CompileJavaTaskMutator mutator = new CompileJavaTaskMutator(project, compileJava.getClasspath(), moduleOptions);
2528

2629
// when
27-
CompileJavaTaskMutator.mutateJavaCompileTask(project, compileJava);
30+
mutator.modularizeJavaCompileTask(compileJava);
2831

2932
// then
3033
List<String> twoLastArguments = twoLastCompilerArgs(compileJava);

‎test-project-kotlin/greeter.api/build.gradle.kts

+3-2
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,13 @@
1-
import org.javamodularity.moduleplugin.tasks.ModuleOptions
1+
import org.javamodularity.moduleplugin.extensions.CompileModuleOptions
22
import org.javamodularity.moduleplugin.tasks.TestModuleOptions
33
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
44

55
//region NO-OP (DSL testing)
66
tasks {
77
compileJava {
8-
extensions.configure(ModuleOptions::class) {
8+
extensions.configure(CompileModuleOptions::class) {
99
addModules = listOf()
10+
compileModuleInfoSeparately = false
1011
}
1112
}
1213

‎test-project/greeter.api/build.gradle

+1
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@ plugins {
66
compileJava {
77
moduleOptions {
88
addModules = []
9+
compileModuleInfoSeparately = false
910
}
1011
}
1112

0 commit comments

Comments
 (0)
Please sign in to comment.