#89: introduced TaskOption class for easier configuration of all task…

… arguments (including JavadocTask)
java9-modularity · May 8, 2019 · 4014f02 · 4014f02
1 parent 8d84487
commit 4014f02
Show file tree

Hide file tree

Showing 12 changed files with 219 additions and 123 deletions.
diff --git a/src/main/java/org/javamodularity/moduleplugin/internal/PatchModuleResolver.java b/src/main/java/org/javamodularity/moduleplugin/internal/PatchModuleResolver.java
@@ -4,6 +4,7 @@
 import org.gradle.api.logging.Logging;
 import org.javamodularity.moduleplugin.tasks.PatchModuleExtension;
 
+import java.util.List;
 import java.util.Objects;
 import java.util.function.UnaryOperator;
 import java.util.stream.Stream;
@@ -23,15 +24,16 @@ public PatchModuleResolver(PatchModuleExtension patchModuleExtension, UnaryOpera
         this.jarNameResolver = jarNameResolver;
     }
 
-    public Stream<String> toArgumentStream() {
-        return toValueStream().flatMap(value -> Stream.of("--patch-module", value));
+    public void mutateArgs(List<String> args) {
+        buildOptionStream().forEach(option -> option.mutateArgs(args));
     }
 
-    public Stream<String> toValueStream() {
+    public Stream<TaskOption> buildOptionStream() {
         return patchModuleExtension.getConfig().stream()
                 .map(patch -> patch.split("="))
                 .map(this::resolvePatchModuleValue)
-                .filter(Objects::nonNull);
+                .filter(Objects::nonNull)
+                .map(value -> new TaskOption("--patch-module", value));
     }
 
     private String resolvePatchModuleValue(String[] parts) {

diff --git a/src/main/java/org/javamodularity/moduleplugin/internal/StreamHelper.java b/src/main/java/org/javamodularity/moduleplugin/internal/StreamHelper.java
@@ -0,0 +1,12 @@
+package org.javamodularity.moduleplugin.internal;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+public final class StreamHelper {
+
+    @SafeVarargs
+    public static <T> Stream<T> concat(Stream<T>... streams) {
+        return Arrays.stream(streams).reduce(Stream::concat).orElseThrow(IllegalArgumentException::new);
+    }
+}
diff --git a/src/main/java/org/javamodularity/moduleplugin/internal/TaskOption.java b/src/main/java/org/javamodularity/moduleplugin/internal/TaskOption.java
@@ -0,0 +1,64 @@
+package org.javamodularity.moduleplugin.internal;
+
+import org.gradle.external.javadoc.CoreJavadocOptions;
+
+import java.util.List;
+
+/**
+ * Stores a flag and its value that can be used as: compiler args, JVM args, and Javadoc options.
+ */
+public final class TaskOption {
+
+    /**
+     * E.g. {@code --add-modules}.
+     */
+    private final String flag;
+    /**
+     * E.g. {@code java.sql,my.module}.
+     */
+    private final String value;
+
+    public TaskOption(String flag, String value) {
+        this.flag = flag;
+        this.value = value;
+        this.validate();
+    }
+
+    private void validate() {
+        if (!flag.startsWith("--")) {
+            throw new IllegalArgumentException("Invalid flag: " + flag);
+        }
+        if (value.isBlank() || value.contains(" ")) {
+            throw new IllegalArgumentException("Invalid value: " + value);
+        }
+    }
+
+    public String getFlag() {
+        return flag;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    /**
+     * Javadoc takes options without the initial hyphen.
+     *
+     * @return the Javadoc flag
+     * @see org.gradle.external.javadoc.internal.JavadocOptionFileWriterContext#writeOptionHeader(String)
+     */
+    public String getJavadocFlag() {
+        return flag.substring(1);
+    }
+
+    //region MUTATE
+    public void mutateArgs(List<String> args) {
+        args.add(flag);
+        args.add(value);
+    }
+
+    public void mutateOptions(CoreJavadocOptions options) {
+        options.addStringOption(getJavadocFlag(), value);
+    }
+    //endregion
+}
diff --git a/src/main/java/org/javamodularity/moduleplugin/tasks/CompileJavaTaskMutator.java b/src/main/java/org/javamodularity/moduleplugin/tasks/CompileJavaTaskMutator.java
@@ -9,7 +9,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Stream;
 
 class CompileJavaTaskMutator {
 
@@ -50,16 +49,13 @@ void modularizeJavaCompileTask(JavaCompile javaCompile) {
     private List<String> buildCompilerArgs(JavaCompile javaCompile) {
         var compilerArgs = new ArrayList<>(javaCompile.getOptions().getCompilerArgs());
 
-        String moduleName = helper().moduleName();
         var patchModuleExtension = helper().extension(PatchModuleExtension.class);
 
-        Stream.of("--module-path", patchModuleExtension.getUnpatchedClasspathAsPath(compileJavaClasspath))
-                .forEach(compilerArgs::add);
+        patchModuleExtension.buildModulePathOption(compileJavaClasspath)
+                .ifPresent(option -> option.mutateArgs(compilerArgs));
+        patchModuleExtension.resolvePatched(compileJavaClasspath).mutateArgs(compilerArgs);
 
-        moduleOptions.mutateArgs(moduleName, compilerArgs);
-
-        patchModuleExtension.resolve(compileJavaClasspath).toArgumentStream()
-                .forEach(compilerArgs::add);
+        moduleOptions.mutateArgs(compilerArgs);
 
         return compilerArgs;
     }

diff --git a/src/main/java/org/javamodularity/moduleplugin/tasks/CompileTestTask.java b/src/main/java/org/javamodularity/moduleplugin/tasks/CompileTestTask.java
@@ -3,13 +3,14 @@
 import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
+import org.gradle.api.file.FileCollection;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.tasks.compile.JavaCompile;
 import org.javamodularity.moduleplugin.TestEngine;
+import org.javamodularity.moduleplugin.internal.TaskOption;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Stream;
 
 public class CompileTestTask extends AbstractModulePluginTask {
 
@@ -41,23 +42,23 @@ private List<String> buildCompilerArgs(JavaCompile compileTestJava, ModuleOption
 
         String moduleName = helper().moduleName();
         var patchModuleExtension = helper().extension(PatchModuleExtension.class);
+        FileCollection classpath = compileTestJava.getClasspath();
 
-        Stream.of(
-                "--module-path",
-                patchModuleExtension.getUnpatchedClasspathAsPath(compileTestJava.getClasspath()),
+        patchModuleExtension.buildModulePathOption(classpath).ifPresent(option -> option.mutateArgs(compilerArgs));
+
+        new TaskOption(
                 "--patch-module",
                 moduleName + "=" + helper().testSourceSet().getJava().getSourceDirectories().getAsPath()
-        ).forEach(compilerArgs::add);
+        ).mutateArgs(compilerArgs);
 
-        TestEngine.select(project).ifPresent(testEngine -> Stream.of(
-                "--add-modules", testEngine.moduleName,
-                "--add-reads", moduleName + "=" + testEngine.moduleName
-        ).forEach(compilerArgs::add));
+        TestEngine.select(project).ifPresent(testEngine -> {
+            new TaskOption("--add-modules", testEngine.moduleName).mutateArgs(compilerArgs);
+            new TaskOption("--add-reads", moduleName + "=" + testEngine.moduleName).mutateArgs(compilerArgs);
+        });
 
-        moduleOptions.mutateArgs(moduleName, compilerArgs);
+        moduleOptions.mutateArgs(compilerArgs);
 
-        patchModuleExtension.resolve(compileTestJava.getClasspath()).toArgumentStream()
-                .forEach(compilerArgs::add);
+        patchModuleExtension.resolvePatched(classpath).mutateArgs(compilerArgs);
 
         ModuleInfoTestHelper.mutateArgs(project, compilerArgs::add);
 

diff --git a/src/main/java/org/javamodularity/moduleplugin/tasks/JavadocTask.java b/src/main/java/org/javamodularity/moduleplugin/tasks/JavadocTask.java
@@ -3,9 +3,11 @@
 import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
+import org.gradle.api.file.FileCollection;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.tasks.javadoc.Javadoc;
 import org.gradle.external.javadoc.CoreJavadocOptions;
+import org.javamodularity.moduleplugin.internal.StreamHelper;
 
 public class JavadocTask extends AbstractModulePluginTask {
 
@@ -34,16 +36,13 @@ public void execute(Task task) {
     private void addJavadocOptions(Javadoc javadoc, ModuleOptions moduleOptions) {
         var options = (CoreJavadocOptions) javadoc.getOptions();
         var patchModuleExtension = helper().extension(PatchModuleExtension.class);
+        FileCollection classpath = javadoc.getClasspath();
 
-        String modulePath = patchModuleExtension.getUnpatchedClasspathAsPath(javadoc.getClasspath());
-        options.addStringOption("-module-path", modulePath);
-
-        if (!moduleOptions.getAddModules().isEmpty()) {
-            String addModules = String.join(",", moduleOptions.getAddModules());
-            options.addStringOption("-add-modules", addModules);
-        }
-
-        patchModuleExtension.resolve(javadoc.getClasspath()).toValueStream()
-                .forEach(value -> options.addStringOption("-patch-module", value));
+        StreamHelper.concat(
+                patchModuleExtension.buildModulePathOption(classpath).stream(),
+                patchModuleExtension.resolvePatched(classpath).buildOptionStream(),
+                moduleOptions.buildFullOptionStream()
+        ).forEach(option -> option.mutateOptions(options));
     }
+
 }
diff --git a/src/main/java/org/javamodularity/moduleplugin/tasks/ModuleOptions.java b/src/main/java/org/javamodularity/moduleplugin/tasks/ModuleOptions.java
@@ -3,21 +3,25 @@
 import org.gradle.api.Project;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
+import org.javamodularity.moduleplugin.JavaProjectHelper;
+import org.javamodularity.moduleplugin.internal.TaskOption;
+import org.javamodularity.moduleplugin.internal.StreamHelper;
 
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Stream;
 
 public class ModuleOptions {
     private static final Logger LOGGER = Logging.getLogger(ModuleOptions.class);
 
+    private final Project project;
+
     private List<String> addModules = new ArrayList<>();
     private Map<String, String> addReads = new LinkedHashMap<>();
     private Map<String, String> addExports = new LinkedHashMap<>();
     private Map<String, String> addOpens = new LinkedHashMap<>();
 
     public ModuleOptions(Project project) {
+        this.project = project;
     }
 
     public List<String> getAddModules() {
@@ -52,30 +56,52 @@ public void setAddOpens(Map<String, String> addOpens) {
         this.addOpens = addOpens;
     }
 
-    protected void mutateArgs(String moduleName, List<String> args) {
-        if (!getAddModules().isEmpty()) {
-            String addModules = String.join(",", getAddModules());
-            args.add("--add-modules");
-            args.add(addModules);
-            LOGGER.debug("Adding modules '{}' to patch module {}...", addModules, moduleName);
+    //region MODULE TASK OPTION
+    public void mutateArgs(List<String> args) {
+        buildFullOptionStream().forEach(o -> o.mutateArgs(args));
+    }
+
+    public Stream<TaskOption> buildFullOptionStream() {
+        LOGGER.debug("Updating module '{}' with...", helper().moduleName());
+        return StreamHelper.concat(
+                addModulesOption().stream(),
+                addReadsOptionStream(),
+                addExportsOptionStream(),
+                addOpensOptionStream()
+        ).peek(option -> LOGGER.debug("  {} {}", option.getFlag(), option.getValue()));
+    }
+
+    private Optional<TaskOption> addModulesOption() {
+        if (addModules.isEmpty()) {
+            return Optional.empty();
         }
+        return Optional.of(new TaskOption("--add-modules", String.join(",", addModules)));
+    }
+
+    private Stream<TaskOption> addReadsOptionStream() {
+        return buildOptionStream("--add-reads", addReads);
+    }
 
-        mutateArgs(moduleName, args, getAddReads(), "--add-reads");
-        mutateArgs(moduleName, args, getAddExports(), "--add-exports");
-        mutateArgs(moduleName, args, getAddOpens(), "--add-opens");
-    }
-
-    private void mutateArgs(String moduleName, List<String> args, Map<String, String> src, String flag) {
-        if (!src.isEmpty()) {
-            LOGGER.debug("Updating module '{}' with...", moduleName);
-            src.entrySet().stream()
-                .map(e -> e.getKey() + "=" + e.getValue())
-                .forEach(e -> {
-                    LOGGER.debug("  {}", flag);
-                    LOGGER.debug("  {}", e);
-                    args.add(flag);
-                    args.add(e);
-                });
+    private Stream<TaskOption> addExportsOptionStream() {
+        return buildOptionStream("--add-exports", addExports);
+    }
+
+    private Stream<TaskOption> addOpensOptionStream() {
+        return buildOptionStream("--add-opens", addOpens);
+    }
+
+    private Stream<TaskOption> buildOptionStream(String flag, Map<String, String> map) {
+        if (map.isEmpty()) {
+            return Stream.empty();
         }
+
+        return map.entrySet().stream()
+                .map(entry -> entry.getKey() + "=" + entry.getValue())
+                .map(value -> new TaskOption(flag, value));
+    }
+    //endregion
+
+    private JavaProjectHelper helper() {
+        return new JavaProjectHelper(project);
     }
 }
diff --git a/src/main/java/org/javamodularity/moduleplugin/tasks/PatchModuleExtension.java b/src/main/java/org/javamodularity/moduleplugin/tasks/PatchModuleExtension.java
@@ -1,6 +1,7 @@
 package org.javamodularity.moduleplugin.tasks;
 
 import org.gradle.api.file.FileCollection;
+import org.javamodularity.moduleplugin.internal.TaskOption;
 import org.javamodularity.moduleplugin.internal.PatchModuleResolver;
 
 import java.io.File;
@@ -21,11 +22,11 @@ public void setConfig(List<String> config) {
         indexByJar = config.stream().map(s -> s.split("=")).collect(Collectors.toMap(c -> c[1], c -> c[0]));
     }
 
-    public PatchModuleResolver resolve(FileCollection classpath) {
-        return resolve(jarName -> classpath.filter(jar -> jar.getName().endsWith(jarName)).getAsPath());
+    public PatchModuleResolver resolvePatched(FileCollection classpath) {
+        return resolvePatched(jarName -> classpath.filter(jar -> jar.getName().endsWith(jarName)).getAsPath());
     }
 
-    public PatchModuleResolver resolve(UnaryOperator<String> jarNameResolver) {
+    public PatchModuleResolver resolvePatched(UnaryOperator<String> jarNameResolver) {
         return new PatchModuleResolver(this, jarNameResolver);
     }
 
@@ -37,8 +38,12 @@ public boolean isUnpatched(File jar) {
         return !indexByJar.containsKey(jar.getName());
     }
 
-    public String getUnpatchedClasspathAsPath(FileCollection classpath) {
-        return classpath.filter(this::isUnpatched).getAsPath();
+    public Optional<TaskOption> buildModulePathOption(FileCollection classpath) {
+        String modulePath = classpath.filter(this::isUnpatched).getAsPath();
+        if (modulePath.isEmpty()) {
+            return Optional.empty();
+        }
+        return Optional.of(new TaskOption("--module-path", modulePath));
     }
 
     @Override