Merge pull request #17 from tricktron/f-repl-with-source-deps

Repl with all Source Dependencies

8 files changed, 255 insertions, 84 deletions

diff --git a/src/main/java/ch/fhnw/thga/gradleplugins/CompileFregeTask.java b/src/main/java/ch/fhnw/thga/gradleplugins/CompileFregeTask.java
index e81fe76..bc3c8f7 100644
--- a/src/main/java/ch/fhnw/thga/gradleplugins/CompileFregeTask.java
+++ b/src/main/java/ch/fhnw/thga/gradleplugins/CompileFregeTask.java
@@ -3,13 +3,16 @@ package ch.fhnw.thga.gradleplugins;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.BiFunction;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import javax.inject.Inject;
 
 import org.gradle.api.DefaultTask;
+import org.gradle.api.file.Directory;
 import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.FileTree;
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.ListProperty;
@@ -29,6 +32,24 @@ import org.gradle.api.tasks.TaskAction;
 @CacheableTask
 public abstract class CompileFregeTask extends DefaultTask {
     private final JavaExec javaExec;
+    private static final String FREGE_FILES_GLOB_PATTERN          = "**/*.fr";
+    private static final BiFunction<String, Directory, FileTree>
+                                            excludeReplSourceFile =
+        (String replSource,
+        Directory srcDir) ->
+    {
+        if (replSource.isEmpty()) return srcDir.getAsFileTree();
+        return srcDir.getAsFileTree().matching(
+            pattern ->
+            {
+                pattern.exclude(
+                    String.format(
+                    "**/%s",
+                    replSource)
+                );
+            }
+        );
+    };
 
     @InputFile
     @PathSensitive(PathSensitivity.RELATIVE)
@@ -44,6 +65,9 @@ public abstract class CompileFregeTask extends DefaultTask {
     @Input
     public abstract Property<String> getFregeDependencies();
 
+    @Input
+    public abstract Property<String> getReplSource();
+
     @OutputDirectory
     public abstract DirectoryProperty getFregeOutputDir();
 
@@ -58,9 +82,27 @@ public abstract class CompileFregeTask extends DefaultTask {
     }
 
     @Internal
+    public final Provider<FileTree> getSourceFileTree() {
+        return getReplSource().zip(
+            getFregeMainSourceDir(),
+            excludeReplSourceFile);
+    }
+
+    @Internal
+    public final Provider<List<String>> getSourceFiles() {
+        return getSourceFileTree()
+            .map(tree -> tree.matching(pattern -> pattern.include(FREGE_FILES_GLOB_PATTERN)))
+            .map(tree -> tree.getFiles().stream()
+            .map(file -> file.getAbsolutePath())
+            .collect(Collectors.toList())
+        );
+    }
+
+    @Internal
     public final Provider<List<String>> getDependencyArg() {
         return getFregeDependencies().map(depsClasspath -> {
-            return depsClasspath.isEmpty() ? Collections.emptyList() : List.of("-fp", depsClasspath);
+            return depsClasspath.isEmpty() ? Collections.emptyList()
+                                           : List.of("-fp", depsClasspath);
         });
     }
 
@@ -69,16 +111,25 @@ public abstract class CompileFregeTask extends DefaultTask {
         javaExec = objectFactory.newInstance(JavaExec.class);
     }
 
-    private List<String> buildCompilerArgsFromProperties(List<String> directoryArg) {
-        return Stream
-                .of(getDependencyArg().get(), getFregeCompilerFlags().get(), directoryArg, getSourcePathArg().get(),
-                        List.of(getFregeMainSourcePath().get()))
-                .filter(lists -> !lists.isEmpty()).flatMap(Collection::stream).collect(Collectors.toList());
+    private List<String> buildCompilerArgsFromProperties(List<String> directoryArg)
+    {
+        return Stream.of(
+            getDependencyArg().get(),
+            getFregeCompilerFlags().get(),
+            directoryArg,
+            getSourcePathArg().get(),
+            getSourceFiles().get())
+        .filter(lists -> !lists.isEmpty())
+        .flatMap(Collection::stream)
+        .collect(Collectors.toList());
     }
 
     @TaskAction
     public void compileFrege() {
-        List<String> directoryArg = List.of("-d", getFregeOutputDir().getAsFile().get().getAbsolutePath());
+        List<String> directoryArg = List.of(
+            "-d",
+            getFregeOutputDir().getAsFile().get().getAbsolutePath());
+
         javaExec.setClasspath(getProject().files(getFregeCompilerJar()))
                 .setArgs(buildCompilerArgsFromProperties(directoryArg)).exec();
     }
diff --git a/src/main/java/ch/fhnw/thga/gradleplugins/FregeExtension.java b/src/main/java/ch/fhnw/thga/gradleplugins/FregeExtension.java
index ea02493..5bcbf3d 100644
--- a/src/main/java/ch/fhnw/thga/gradleplugins/FregeExtension.java
+++ b/src/main/java/ch/fhnw/thga/gradleplugins/FregeExtension.java
@@ -10,9 +10,9 @@ import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
 
 public abstract class FregeExtension {
-    public static final String DEFAULT_DOWNLOAD_DIRECTORY = "lib";
-    public static final String DEFAULT_RELATIVE_OUTPUT_DIR = "classes/main/frege";
-    public static final String DEFAULT_RELATIVE_SOURCE_DIR = "src/main/frege";
+    public static final String DEFAULT_DOWNLOAD_DIRECTORY   = "lib";
+    public static final String DEFAULT_RELATIVE_OUTPUT_DIR  = "classes/main/frege";
+    public static final String DEFAULT_RELATIVE_SOURCE_DIR  = "src/main/frege";
     public static final List<String> DEFAULT_COMPILER_FLAGS = List.of("-O", "-make");
 
     public abstract Property<String> getVersion();
@@ -29,11 +29,19 @@ public abstract class FregeExtension {
 
     public abstract ListProperty<String> getCompilerFlags();
 
+    public abstract Property<String> getReplSource();
+
     @Inject
     public FregeExtension(ProjectLayout projectLayout) {
-        getCompilerDownloadDir().convention(projectLayout.getProjectDirectory().dir(DEFAULT_DOWNLOAD_DIRECTORY));
-        getMainSourceDir().convention(projectLayout.getProjectDirectory().dir(DEFAULT_RELATIVE_SOURCE_DIR));
-        getOutputDir().convention(projectLayout.getBuildDirectory().dir(DEFAULT_RELATIVE_OUTPUT_DIR));
+        getCompilerDownloadDir()
+        .convention(projectLayout.getProjectDirectory().dir(DEFAULT_DOWNLOAD_DIRECTORY));
+
+        getMainSourceDir()
+        .convention(projectLayout.getProjectDirectory().dir(DEFAULT_RELATIVE_SOURCE_DIR));
+
+        getOutputDir()
+        .convention(projectLayout.getBuildDirectory().dir(DEFAULT_RELATIVE_OUTPUT_DIR));
+
         getCompilerFlags().convention(DEFAULT_COMPILER_FLAGS);
     }
 }
diff --git a/src/main/java/ch/fhnw/thga/gradleplugins/FregePlugin.java b/src/main/java/ch/fhnw/thga/gradleplugins/FregePlugin.java
index 18016f3..a318b81 100644
--- a/src/main/java/ch/fhnw/thga/gradleplugins/FregePlugin.java
+++ b/src/main/java/ch/fhnw/thga/gradleplugins/FregePlugin.java
@@ -3,69 +3,113 @@ package ch.fhnw.thga.gradleplugins;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.file.FileCollection;
-import org.gradle.api.file.RegularFile;
-import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.TaskProvider;
 
 import ch.fhnw.thga.gradleplugins.internal.DependencyFregeTask;
 
-public class FregePlugin implements Plugin<Project> {
-    public static final String SETUP_FREGE_TASK_NAME = "setupFrege";
-    public static final String COMPILE_FREGE_TASK_NAME = "compileFrege";
-    public static final String RUN_FREGE_TASK_NAME = "runFrege";
-    public static final String REPL_FREGE_TASK_NAME = "replFrege";
-    public static final String DEPS_FREGE_TASK_NAME = "depsFrege";
-    public static final String FREGE_PLUGIN_ID = "ch.fhnw.thga.frege";
-    public static final String FREGE_EXTENSION_NAME = "frege";
+public class FregePlugin implements Plugin<Project>
+{
+    public static final String SETUP_FREGE_TASK_NAME      = "setupFrege";
+    public static final String COMPILE_FREGE_TASK_NAME    = "compileFrege";
+    public static final String RUN_FREGE_TASK_NAME        = "runFrege";
+    public static final String REPL_FREGE_TASK_NAME       = "replFrege";
+    public static final String DEPS_FREGE_TASK_NAME       = "depsFrege";
+    public static final String FREGE_PLUGIN_ID            = "ch.fhnw.thga.frege";
+    public static final String FREGE_EXTENSION_NAME       = "frege";
     public static final String FREGE_IMPLEMENTATION_SCOPE = "implementation";
 
-    private FileCollection setupClasspath(Project project, Configuration dependencies,
-            Provider<RegularFile> fregeCompilerJar) {
-        if (dependencies.isEmpty()) {
-            return project.files(fregeCompilerJar);
-        } else {
-            return project.files(fregeCompilerJar, dependencies.getAsPath());
-        }
-    }
-
     @Override
     public void apply(Project project) {
-        Configuration implementation = project.getConfigurations().create(FREGE_IMPLEMENTATION_SCOPE);
-        FregeExtension extension = project.getExtensions().create(FREGE_EXTENSION_NAME, FregeExtension.class);
-        TaskProvider<SetupFregeTask> setupFregeCompilerTask = project.getTasks().register(SETUP_FREGE_TASK_NAME,
-                SetupFregeTask.class, task -> {
+        Configuration implementation = project
+                                       .getConfigurations()
+                                       .create(FREGE_IMPLEMENTATION_SCOPE);
+
+        FregeExtension extension     = project
+                                       .getExtensions()
+                                       .create(
+                                       FREGE_EXTENSION_NAME,
+                                       FregeExtension.class);
+
+        TaskProvider<SetupFregeTask> setupFregeCompilerTask =
+            project.getTasks().register(
+                SETUP_FREGE_TASK_NAME,
+                SetupFregeTask.class,
+                task ->
+                {
                     task.getVersion().set(extension.getVersion());
                     task.getRelease().set(extension.getRelease());
                     task.getDownloadDir().set(extension.getCompilerDownloadDir());
                 });
 
-        TaskProvider<CompileFregeTask> compileFregeTask = project.getTasks().register(COMPILE_FREGE_TASK_NAME,
-                CompileFregeTask.class, task -> {
+        TaskProvider<CompileFregeTask> compileFregeTask =
+            project.getTasks().register(
+                COMPILE_FREGE_TASK_NAME,
+                CompileFregeTask.class,
+                task ->
+                {
                     task.dependsOn(setupFregeCompilerTask);
-                    task.getFregeCompilerJar().set(setupFregeCompilerTask.get().getFregeCompilerOutputPath());
+                    task.getFregeCompilerJar().set(
+                        setupFregeCompilerTask.get().getFregeCompilerOutputPath());
                     task.getFregeMainSourceDir().set(extension.getMainSourceDir());
                     task.getFregeOutputDir().set(extension.getOutputDir());
                     task.getFregeCompilerFlags().set(extension.getCompilerFlags());
                     task.getFregeDependencies().set(implementation.getAsPath());
-                });
-        project.getTasks().register(RUN_FREGE_TASK_NAME, RunFregeTask.class, task -> {
-            task.dependsOn(compileFregeTask);
-            task.getFregeCompilerJar().set(setupFregeCompilerTask.get().getFregeCompilerOutputPath());
-            task.getFregeOutputDir().set(extension.getOutputDir());
-            task.getMainModule().set(extension.getMainModule());
-            task.getFregeDependencies().set(implementation.getAsPath());
-        });
-        project.getTasks().register(DEPS_FREGE_TASK_NAME,
-                DependencyFregeTask.class, task -> {
-                    task.dependsOn(setupFregeCompilerTask);
-                    task.getClasspath().setFrom(setupClasspath(project, implementation,
-                            setupFregeCompilerTask.get().getFregeCompilerOutputPath()));
-                });
-        project.getTasks().register(REPL_FREGE_TASK_NAME, ReplFregeTask.class, task -> {
-            task.dependsOn(setupFregeCompilerTask);
-            task.getFregeClasspath().setFrom(setupClasspath(project, implementation,
-                    setupFregeCompilerTask.get().getFregeCompilerOutputPath()));
-        });
+                    task.getReplSource().set("");
+                }
+            );
+
+        project.getTasks().register(
+            RUN_FREGE_TASK_NAME,
+            RunFregeTask.class,
+            task ->
+            {
+                task.dependsOn(compileFregeTask);
+                task.getFregeCompilerJar().set(
+                    setupFregeCompilerTask.get().getFregeCompilerOutputPath());
+                task.getFregeOutputDir().set(extension.getOutputDir());
+                task.getMainModule().set(extension.getMainModule());
+                task.getFregeDependencies().set(implementation.getAsPath());
+            }
+        );
+
+        project.getTasks().register(
+            DEPS_FREGE_TASK_NAME,
+            DependencyFregeTask.class,
+            task ->
+            {
+                task.dependsOn(compileFregeTask.map(
+                    compileTask ->
+                    {
+                        compileTask.getReplSource().set(task.getReplSource());
+                        return compileTask;
+                    })
+                .get());
+                task.dependsOn(compileFregeTask);
+                task.getFregeCompilerJar().set(
+                    setupFregeCompilerTask.get().getFregeCompilerOutputPath());
+                task.getFregeOutputDir().set(extension.getOutputDir());
+                task.getFregeDependencies().set(implementation.getAsPath());
+            }
+        );
+
+        project.getTasks().register(
+            REPL_FREGE_TASK_NAME,
+            ReplFregeTask.class,
+            task ->
+            {
+                task.getReplSource().set(extension.getReplSource());
+                task.dependsOn(compileFregeTask.map(
+                    compileTask ->
+                    {
+                        compileTask.getReplSource().set(task.getReplSource());
+                        return compileTask;
+                    })
+                .get());
+                task.getFregeCompilerJar().set(
+                    setupFregeCompilerTask.get().getFregeCompilerOutputPath());
+                task.getFregeOutputDir().set(extension.getOutputDir());
+                task.getFregeDependencies().set(implementation.getAsPath());
+            }
+        );
     }
 }
diff --git a/src/main/java/ch/fhnw/thga/gradleplugins/ReplFregeTask.java b/src/main/java/ch/fhnw/thga/gradleplugins/ReplFregeTask.java
index 81da1cd..dd18270 100644
--- a/src/main/java/ch/fhnw/thga/gradleplugins/ReplFregeTask.java
+++ b/src/main/java/ch/fhnw/thga/gradleplugins/ReplFregeTask.java
@@ -1,19 +1,43 @@
 package ch.fhnw.thga.gradleplugins;
 
 import org.gradle.api.DefaultTask;
-import org.gradle.api.file.ConfigurableFileCollection;
-import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputDirectory;
+import org.gradle.api.tasks.InputFile;
 import org.gradle.api.tasks.TaskAction;
+import org.gradle.api.tasks.options.Option;
 
 public abstract class ReplFregeTask extends DefaultTask {
     public static final String REPL_MAIN_CLASS = "frege.repl.FregeRepl";
 
-    @InputFiles
-    public abstract ConfigurableFileCollection getFregeClasspath();
+    @InputFile
+    public abstract RegularFileProperty getFregeCompilerJar();
+
+    @Input
+    public abstract Property<String> getFregeDependencies();
+
+    @InputDirectory
+    public abstract DirectoryProperty getFregeOutputDir();
+
+    @Input
+    @Option(option     = "replSource",
+           description = "The filename which you want to load into the repl, e.g. 'myFregeFile.fr'")
+    public abstract Property<String> getReplSource();
 
     @TaskAction
     public void printStartFregeReplCommand() {
         System.out.println("Execute the following command to start the Frege Repl:");
-        System.out.println(String.format("java -cp %s %s", getFregeClasspath().getAsPath(), REPL_MAIN_CLASS));
+        System.out.println(String.format(
+            "java -cp %s %s",
+            SharedTaskLogic.setupClasspath(
+                getProject(),
+                getFregeDependencies(),
+                getFregeCompilerJar(),
+                getFregeOutputDir())
+            .get().getAsPath(),
+            REPL_MAIN_CLASS));
     }
 }
diff --git a/src/main/java/ch/fhnw/thga/gradleplugins/RunFregeTask.java b/src/main/java/ch/fhnw/thga/gradleplugins/RunFregeTask.java
index 41ac2a3..f993af4 100644
--- a/src/main/java/ch/fhnw/thga/gradleplugins/RunFregeTask.java
+++ b/src/main/java/ch/fhnw/thga/gradleplugins/RunFregeTask.java
@@ -4,17 +4,14 @@ import javax.inject.Inject;
 
 import org.gradle.api.DefaultTask;
 import org.gradle.api.file.DirectoryProperty;
-import org.gradle.api.file.FileCollection;
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.Property;
-import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.InputDirectory;
 import org.gradle.api.tasks.InputFile;
-import org.gradle.api.tasks.Internal;
 import org.gradle.api.tasks.JavaExec;
 import org.gradle.api.tasks.TaskAction;
 import org.gradle.api.tasks.options.Option;
@@ -30,20 +27,13 @@ public abstract class RunFregeTask extends DefaultTask {
     public abstract DirectoryProperty getFregeOutputDir();
 
     @Input
-    @Option(option = "mainModule", description = "The full name of the Frege module with a main function, e.g. 'my.mod.Name'")
+    @Option(option = "mainModule",
+           description = "The full name of the Frege module with a main function, e.g. 'my.mod.Name'")
     public abstract Property<String> getMainModule();
 
     @Input
     public abstract Property<String> getFregeDependencies();
 
-    @Internal
-    public final Provider<FileCollection> getClasspath() {
-        return getFregeDependencies().map(depsClasspath -> {
-            return depsClasspath.isEmpty() ? getProject().files(getFregeCompilerJar(), getFregeOutputDir())
-                    : getProject().files(getFregeCompilerJar(), getFregeOutputDir(), depsClasspath);
-        });
-    }
-
     @Inject
     public RunFregeTask(ObjectFactory objectFactory) {
         javaExec = objectFactory.newInstance(JavaExec.class);
@@ -52,6 +42,12 @@ public abstract class RunFregeTask extends DefaultTask {
     @TaskAction
     public void runFrege() {
         javaExec.getMainClass().set(getMainModule());
-        javaExec.setClasspath(getClasspath().get()).exec();
+        javaExec.setClasspath(
+            SharedTaskLogic.setupClasspath(
+                getProject(),
+                getFregeDependencies(),
+                getFregeCompilerJar(),
+                getFregeOutputDir())
+        .get()).exec();
     }
 }
diff --git a/src/main/java/ch/fhnw/thga/gradleplugins/SetupFregeTask.java b/src/main/java/ch/fhnw/thga/gradleplugins/SetupFregeTask.java
index 1b12f56..6bfe72d 100644
--- a/src/main/java/ch/fhnw/thga/gradleplugins/SetupFregeTask.java
+++ b/src/main/java/ch/fhnw/thga/gradleplugins/SetupFregeTask.java
@@ -21,9 +21,10 @@ import org.gradle.api.tasks.OutputFile;
 import org.gradle.api.tasks.TaskAction;
 
 public abstract class SetupFregeTask extends DefaultTask {
-    public static final Logger LOGGER = Logging.getLogger(SetupFregeTask.class);
+    public static final Logger LOGGER                   = Logging.getLogger(SetupFregeTask.class);
 
-    private static final String FREGE_GITHUB_URL_PREFIX = "https://github.com/Frege/frege/releases/download";
+    private static final String FREGE_GITHUB_URL_PREFIX =
+                                               "https://github.com/Frege/frege/releases/download";
 
     @Input
     public abstract Property<String> getVersion();
diff --git a/src/main/java/ch/fhnw/thga/gradleplugins/SharedTaskLogic.java b/src/main/java/ch/fhnw/thga/gradleplugins/SharedTaskLogic.java
new file mode 100644
index 0000000..57af617
--- /dev/null
+++ b/src/main/java/ch/fhnw/thga/gradleplugins/SharedTaskLogic.java
@@ -0,0 +1,22 @@
+package ch.fhnw.thga.gradleplugins;
+
+import org.gradle.api.Project;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.provider.Property;
+
+public final class SharedTaskLogic {
+    private SharedTaskLogic() {};
+
+    public static final Provider<FileCollection> setupClasspath(
+        Project project,
+        Property<String> dependencies,
+        Object... paths)
+    {
+        return dependencies.map(depsClasspath ->
+        {
+            return depsClasspath.isEmpty() ? project.files(paths)
+                                           : project.files(depsClasspath, paths);
+        });
+    }
+}
diff --git a/src/main/java/ch/fhnw/thga/gradleplugins/internal/DependencyFregeTask.java b/src/main/java/ch/fhnw/thga/gradleplugins/internal/DependencyFregeTask.java
index 34b33a2..87f4d2b 100644
--- a/src/main/java/ch/fhnw/thga/gradleplugins/internal/DependencyFregeTask.java
+++ b/src/main/java/ch/fhnw/thga/gradleplugins/internal/DependencyFregeTask.java
@@ -1,16 +1,41 @@
 package ch.fhnw.thga.gradleplugins.internal;
 
 import org.gradle.api.DefaultTask;
-import org.gradle.api.file.ConfigurableFileCollection;
-import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputDirectory;
+import org.gradle.api.tasks.InputFile;
 import org.gradle.api.tasks.TaskAction;
+import org.gradle.api.tasks.options.Option;
+
+import ch.fhnw.thga.gradleplugins.SharedTaskLogic;
 
 public abstract class DependencyFregeTask extends DefaultTask {
-    @InputFiles
-    public abstract ConfigurableFileCollection getClasspath();
+    @InputFile
+    public abstract RegularFileProperty getFregeCompilerJar();
+
+    @Input
+    public abstract Property<String> getFregeDependencies();
+
+    @InputDirectory
+    public abstract DirectoryProperty getFregeOutputDir();
+
+    @Input
+    @Option(option     = "replSource",
+           description = "The filename which you want to load into the repl, e.g. 'myFregeFile.fr'")
+    public abstract Property<String> getReplSource();
+
 
     @TaskAction
     public void fregeDependencies() {
-        System.out.println(getClasspath().getAsPath());
+        System.out.println(
+            SharedTaskLogic.setupClasspath(
+                getProject(),
+                getFregeDependencies(),
+                getFregeCompilerJar(),
+                getFregeOutputDir())
+            .get().getAsPath());
     }
 }