Adding ragconnect, 0.2.5

build.gradle

@@ -3,14 +3,14 @@ plugins {
   id 'java-gradle-plugin'
 }
 
-group 'org.jastadd.relast'
-version '0.2.4'
+group 'org.jastadd.preprocessor'
+version '0.2.5'
 
 gradlePlugin {
     plugins {
         RelastPlugin {
-            id = 'relast-test'
-            implementationClass = 'org.jastadd.relast.plugin.RelastPlugin'
+            id = 'testing'
+            implementationClass = 'org.jastadd.preprocessor.testing.plugin.PreprocessorPlugin'
         }
     }
 }
@@ -19,8 +19,8 @@ gradlePlugin {
 publishing {
     publications {
         maven(MavenPublication) {
-          groupId = "org.jastadd.relast"
-          artifactId = "relast-test"
+          groupId = "org.jastadd.preprocessor"
+          artifactId = "testing"
         }
     }
     repositories {

src/main/java/org/jastadd/relast/plugin/CompilerLocationExtension.java → src/main/java/org/jastadd/preprocessor/testing/plugin/CompilerLocationExtension.java

-package org.jastadd.relast.plugin;
+package org.jastadd.preprocessor.testing.plugin;
 
 import org.gradle.api.Project;
 import org.gradle.api.provider.Property;
@@ -9,13 +9,19 @@ import org.gradle.api.provider.Property;
  * @author rschoene - Initial contribution
  */
 public class CompilerLocationExtension {
-  public Property<String> compilerLocation;
+  public Property<String> relastCompilerLocation;
+  public Property<String> ragconnectCompilerLocation;
 
   public CompilerLocationExtension(Project project) {
-    compilerLocation = project.getObjects().property(String.class);
+    relastCompilerLocation = project.getObjects().property(String.class);
+    ragconnectCompilerLocation = project.getObjects().property(String.class);
   }
 
-  public Property<String> getCompilerLocation() {
-    return compilerLocation;
+  public Property<String> getRelastCompilerLocation() {
+    return relastCompilerLocation;
+  }
+
+  public Property<String> getRagconnectCompilerLocation() {
+    return ragconnectCompilerLocation;
   }
 }

src/main/java/org/jastadd/preprocessor/testing/plugin/JastAddConfiguration.java

+package org.jastadd.preprocessor.testing.plugin;
+
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputDirectory;
+
+import java.io.File;
+import java.nio.file.Paths;
+import java.util.List;
+
+/**
+ * Configuration options for JastAdd.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class JastAddConfiguration {
+  @Optional
+  @Input
+  String jastAddList;
+
+  @Input
+  String packageName;
+
+  @InputFiles
+  List<File> inputFiles;
+
+  @Input
+  boolean run = true;
+
+  @Optional
+  @Input
+  List<String> extraOptions;
+
+  @OutputDirectory
+  File outputDir = Paths.get("src", "test", "java-gen").toFile();
+}

src/main/java/org/jastadd/relast/plugin/RelastPlugin.java → src/main/java/org/jastadd/preprocessor/testing/plugin/PreprocessorPlugin.java

-package org.jastadd.relast.plugin;
+package org.jastadd.preprocessor.testing.plugin;
 
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
@@ -8,32 +8,48 @@ import org.gradle.api.tasks.TaskCollection;
 import java.util.Set;
 
 /**
- * Plugin for RelAst-Test.
+ * Plugin for preprocessor.testing.
  *
  * @author rschoene - Initial contribution
  */
-public class RelastPlugin implements Plugin<Project> {
+public class PreprocessorPlugin implements Plugin<Project> {
 
   private Task testTask;
 
   @Override
   public void apply(Project project) {
     CompilerLocationExtension extension = project.getExtensions().create(
-        "relastTest",
+        "preprocessor.testing",
         CompilerLocationExtension.class,
         project);
 
-    Set<Task> tasks = project.getTasksByName("test", false);
-    // there should be only one task "test"
+    Set<Task> tasks = project.getTasksByName("compileTestJava", false);
+    // there should be only one task "compileTestJava"
     testTask = tasks.iterator().next();
     TaskCollection<RelastTest> relastTests = project.getTasks().withType(RelastTest.class);
-    relastTests.forEach(relastTest -> setupRelastTest(relastTest, extension.getCompilerLocation().getOrNull()));
-    relastTests.whenTaskAdded(relastTest -> setupRelastTest(relastTest, extension.getCompilerLocation().getOrNull()));
+    relastTests.forEach(relastTest -> setupRelastTest(relastTest,
+        extension.getRelastCompilerLocation().getOrNull()));
+//    relastTests.whenTaskAdded(relastTest -> setupRelastTest(relastTest, extension.getRelastCompilerLocation().getOrNull()));
+    TaskCollection<RagConnectTest> ragconnectTests = project.getTasks().withType(RagConnectTest.class);
+    ragconnectTests.forEach(relastTest -> setupRagconnectTest(relastTest,
+        extension.getRelastCompilerLocation().getOrNull(),
+        extension.getRagconnectCompilerLocation().getOrNull()));
   }
 
   private void setupRelastTest(RelastTest relastTest, String compilerLocation) {
     testTask.dependsOn(relastTest);
     relastTest.setCompilerLocation(compilerLocation);
     relastTest.setGroup("verification");
+    relastTest.setDescription("Runs a relast test");
+  }
+
+  private void setupRagconnectTest(RagConnectTest ragConnectTest,
+                                   String relastCompilerLocation,
+                                   String ragconnectCompilerLocation) {
+    testTask.dependsOn(ragConnectTest);
+    ragConnectTest.setRelastCompilerLocation(relastCompilerLocation);
+    ragConnectTest.setRagconnectCompilerLocation(ragconnectCompilerLocation);
+    ragConnectTest.setGroup("verification");
+    ragConnectTest.setDescription("Runs a ragconnect test");
   }
 }

src/main/java/org/jastadd/preprocessor/testing/plugin/PreprocessorTest.java

+package org.jastadd.preprocessor.testing.plugin;
+
+/**
+ * Abstract base class for all tests.
+ *
+ * @author rschoene - Initial contribution
+ */
+public abstract class PreprocessorTest {
+}

src/main/java/org/jastadd/preprocessor/testing/plugin/RagConnectConfiguration.java

+package org.jastadd.preprocessor.testing.plugin;
+
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.Optional;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * Configuration options for RagConnect.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class RagConnectConfiguration {
+  @Input
+  String rootNode;
+
+  @Input
+  boolean logReads;
+
+  @Input
+  boolean logWrites;
+
+  @Input
+  String outputDir;
+
+  @Optional
+  @Input
+  List<String> protocols;
+
+  @InputFiles
+  List<File> inputFiles;
+
+  @Input
+  boolean verbose = false;
+}

src/main/java/org/jastadd/preprocessor/testing/plugin/RagConnectTest.java

+package org.jastadd.preprocessor.testing.plugin;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.Project;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.tasks.Nested;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.SourceSetContainer;
+import org.gradle.api.tasks.TaskAction;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * RagConnect Test Task.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class RagConnectTest extends DefaultTask {
+
+  @Nested
+  RagConnectConfiguration ragconnect;
+
+  @Nested
+  RelastConfiguration relast;
+
+  @Nested
+  JastAddConfiguration jastadd;
+
+  private String relastCompilerLocation;
+  private String ragconnectCompilerLocation;
+
+  public void setRelastCompilerLocation(String relastCompilerLocation) {
+    this.relastCompilerLocation = relastCompilerLocation;
+  }
+
+  public void setRagconnectCompilerLocation(String ragconnectCompilerLocation) {
+    this.ragconnectCompilerLocation = ragconnectCompilerLocation;
+  }
+
+  @TaskAction
+  void taskAction() throws IOException {
+    runTest();
+  }
+
+  protected void runTest() throws IOException {
+    // run ragconnect before
+    Project project = getProject();
+    String absoluteProjectPath = project.getProjectDir().getAbsolutePath();
+    // TODO maybe generated files should be deleted here?
+    project.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
+      SourceSetContainer sourceSets = (SourceSetContainer) project.getProperties().get("sourceSets");
+      FileCollection runtimeClasspath = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getRuntimeClasspath();
+      project.javaexec(javaExecSpec -> {
+        List<Object> args = new ArrayList<>();
+        javaExecSpec.setClasspath(runtimeClasspath);
+        if (ragconnectCompilerLocation != null) {
+          javaExecSpec.setMain("-jar");
+          args.add(ragconnectCompilerLocation);
+        } else {
+          javaExecSpec.setMain("org.jastadd.ragconnect.compiler.Compiler");
+        }
+        args.add("--o=" + ragconnect.outputDir);
+        args.add("--rootNode=" + ragconnect.rootNode);
+        if (ragconnect.logReads) {
+          args.add("--logReads");
+        }
+        if (ragconnect.logWrites) {
+          args.add("--logWrites");
+        }
+        if (ragconnect.verbose) {
+          args.add("--verbose");
+        }
+        if (ragconnect.protocols != null && !ragconnect.protocols.isEmpty()) {
+          args.add("--protocols=" + String.join(",", ragconnect.protocols));
+        }
+        args.addAll(ragconnect.inputFiles);
+        javaExecSpec.args(args);
+      }).assertNormalExitValue();
+    });
+
+
+    // now run relast + jastadd
+    RelastTest relastTest = new RelastTest();
+    relastTest.jastadd = jastadd;
+    relastTest.relast = relast;
+    relastTest.setCompilerLocation(relastCompilerLocation);
+    relastTest.runTest();
+  }
+}

src/main/java/org/jastadd/preprocessor/testing/plugin/RelastConfiguration.java

+package org.jastadd.preprocessor.testing.plugin;
+
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.Optional;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * Configuration options for Relast.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class RelastConfiguration {
+  @Input
+  boolean useJastAddNames;
+
+  @Input
+  String grammarName;
+
+  @InputFiles
+  @Optional
+  List<File> inputFiles;
+
+  @Input
+  boolean writeToFile = true;
+
+  @Input
+  boolean resolverHelper = true;
+
+  @Optional
+  @Input
+  String listClass;
+
+  @Optional
+  @Input
+  String serializer;
+
+  @Input
+  boolean verbose = false;
+}

src/main/java/org/jastadd/relast/plugin/RelastTest.java → src/main/java/org/jastadd/preprocessor/testing/plugin/RelastTest.java

-package org.jastadd.relast.plugin;
+package org.jastadd.preprocessor.testing.plugin;
 
 import org.gradle.api.DefaultTask;
 import org.gradle.api.Project;
 import org.gradle.api.file.FileCollection;
 import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.tasks.Input;
-import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.Nested;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.SourceSetContainer;
 import org.gradle.api.tasks.TaskAction;
 
 import java.io.IOException;
-import java.nio.file.*;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -22,183 +23,20 @@ import java.util.stream.Collectors;
  *
  * @author rschoene - Initial contribution
  */
-@SuppressWarnings({"unused", "WeakerAccess"})
 public class RelastTest extends DefaultTask {
   // configuration from plugin
   private String compilerLocation;
-  // general options
-  private boolean verbose = false;
-  // pre-process options
-  private List<String> relastFiles = new ArrayList<>();
-  private boolean useJastAddNames;
-  private boolean resolverHelper;
-  private boolean writeToFile = true;
-  private String grammarName;
-  private String listClass;
-  private String jastAddList;
-  private String serializer;
 
-  // compile options
-  private boolean runJastAdd = true;
-  private String outputDir = "src/test/java-gen/";
-  private String packageName;
-  private final List<String> moreInputFiles = new ArrayList<>();
-  private List<String> extraJastAddOptions = new ArrayList<>();
+  @Nested
+  RelastConfiguration relast;
+
+  @Nested
+  JastAddConfiguration jastadd;
 
   public void setCompilerLocation(String compilerLocation) {
     this.compilerLocation = compilerLocation;
   }
 
-  @Input
-  public boolean isVerbose() {
-    return verbose;
-  }
-
-  public void setVerbose(boolean verbose) {
-    this.verbose = verbose;
-  }
-
-  // pre-process options
-  @Input
-  public List<String> getRelastFiles() {
-    return relastFiles;
-  }
-
-  public void relastFiles(String relastFile) {
-    this.relastFiles.add(relastFile);
-  }
-
-  public void relastFiles(String[] relastFilesArray) {
-    this.relastFiles = Arrays.asList(relastFilesArray);
-  }
-
-  @Input
-  public boolean isUseJastAddNames() {
-    return useJastAddNames;
-  }
-
-  public void setUseJastAddNames(boolean useJastAddNames) {
-    this.useJastAddNames = useJastAddNames;
-  }
-
-  @Input
-  public boolean isResolverHelper() {
-    return resolverHelper;
-  }
-
-  public void setResolverHelper(boolean resolverHelper) {
-    this.resolverHelper = resolverHelper;
-  }
-
-  @Input
-  public boolean isWriteToFile() {
-    return writeToFile;
-  }
-
-  public void setWriteToFile(boolean writeToFile) {
-    this.writeToFile = writeToFile;
-  }
-
-  @Input
-  public String getGrammarName() {
-    return grammarName;
-  }
-
-  public void setGrammarName(String grammarName) {
-    this.grammarName = grammarName;
-  }
-
-  @Optional
-  @Input
-  public String getListClass() {
-    return listClass;
-  }
-
-  public void setListClass(String listClass) {
-    this.listClass = listClass;
-  }
-
-  @Optional
-  @Input
-  public String getJastAddList() {
-    return jastAddList;
-  }
-
-  public void setJastAddList(String jastAddList) {
-    this.jastAddList = jastAddList;
-  }
-
-  @Optional
-  @Input
-  public String getSerializer() {
-    return serializer;
-  }
-
-  public void setSerializer(String serializer) {
-    this.serializer = serializer;
-  }
-
-  // compile options
-  @Input
-  public boolean isRunJastAdd() {
-    return runJastAdd;
-  }
-
-  public void setRunJastAdd(boolean runJastAdd) {
-    this.runJastAdd = runJastAdd;
-  }
-
-  @Optional
-  @Input
-  public String getOutputDir() {
-    return outputDir;
-  }
-
-  public void setOutputDir(String outputDir) {
-    this.outputDir = outputDir;
-  }
-
-  @Input
-  public String getPackageName() {
-    return packageName;
-  }
-
-  public void setPackageName(String packageName) {
-    this.packageName = packageName;
-  }
-
-  @Optional
-  @Input
-  public List<String> getExtraJastAddOptions() {
-    return extraJastAddOptions;
-  }
-
-  public void extraJastAddOptions(String f) {
-    this.extraJastAddOptions.add(f);
-  }
-
-  public void extraJastAddOptions(String[] fileArray) {
-    this.extraJastAddOptions.addAll(Arrays.asList(fileArray));
-  }
-
-  @Optional
-  @Input
-  public List<String> getMoreInputFiles() {
-    return moreInputFiles;
-  }
-
-  public void moreInputFiles(String f) {
-    this.moreInputFiles.add(f);
-  }
-
-  public void moreInputFiles(String[] fileArray) {
-    this.moreInputFiles.addAll(Arrays.asList(fileArray));
-  }
-
-  private boolean isSet(String option) {
-    return option != null && !option.isEmpty();
-  }
-
   private final String[] genSuffixes = {".ast", ".jadd", "RefResolver.jadd", "ResolverStubs.jrag", "Serializer.jadd"};
 
   private Path pathToAbsoluteProject(String filename) {
@@ -206,34 +44,34 @@ public class RelastTest extends DefaultTask {
   }
 
   @TaskAction
-  void runTest() throws IOException {
-    setGroup("verification");
-    setDescription("Runs a relast test");
+  void taskAction() throws IOException {
+    runTest();
+  }
+
+  protected void runTest() throws IOException {
     Project project = getProject();
-    String absoluteProjectPath = project.getProjectDir().getAbsolutePath();
-    if (isVerbose()) {
+    if (relast.verbose) {
       System.out.println("Running relast test in " + project.getDisplayName());
-      System.out.println("relast files: " + getRelastFiles());
+      System.out.println("relast files: " + relast.inputFiles);
       System.out.println("Deleting files");
     }
     // first, delete generated files
     List<Path> genFiles = new ArrayList<>();
     for (String suffix : genSuffixes) {
-      genFiles.add(pathToAbsoluteProject(getGrammarName() + suffix));
+      genFiles.add(pathToAbsoluteProject(relast.grammarName + suffix));
     }
-    if (isVerbose()) {
+    if (relast.verbose) {
       System.out.println("gen files: " + genFiles);
     }
     project.delete(deleteSpec -> {
       deleteSpec.delete(genFiles);
-      if (isSet(getPackageName())) {
-        deleteSpec.delete(Paths.get(getOutputDir(), getPackageName()));
-      }
+//      deleteSpec.delete(Paths.get(jastadd.outputDir, jastadd.packageName));
+      deleteSpec.delete(jastadd.outputDir.toPath().resolve(jastadd.packageName));
     });
     // create output directories, if not existing
-    createDirectory(pathToAbsoluteProject(getOutputDir()));
-    createDirectory(pathToAbsoluteProject(getGrammarName()).getParent());
-    if (isVerbose()) {
+    createDirectory(pathToAbsoluteProject(jastadd.outputDir.getName()));
+    createDirectory(pathToAbsoluteProject(relast.grammarName).getParent());
+    if (relast.verbose) {
       System.out.println("Pre processing, running relast");
     }
     // then, run relast pre processing
@@ -249,35 +87,35 @@ public class RelastTest extends DefaultTask {
         } else {
           javaExecSpec.setMain("org.jastadd.relast.compiler.Compiler");
         }
-        args.addAll(getRelastFiles().stream().map(this::pathToAbsoluteProject).collect(Collectors.toList()));
+        args.addAll(relast.inputFiles.stream().map(filename -> pathToAbsoluteProject(filename.getName())).collect(Collectors.toList()));
         args.add("--quiet");
-        if (isWriteToFile()) {
+        if (relast.writeToFile) {
           args.add("--file");
         }
-        if (isUseJastAddNames()) {
+        if (relast.useJastAddNames) {
           args.add("--useJastAddNames");
         }
-        if (isResolverHelper()) {
+        if (relast.resolverHelper) {
           args.add("--resolverHelper");
         }
-        if (isSet(getJastAddList())) {
-          args.add("--jastAddList=" + getJastAddList());
+        if (jastadd.jastAddList != null) {
+          args.add("--jastAddList=" + jastadd.jastAddList);
         }
-        if (isSet(getListClass())) {
-          args.add("--listClass=" + getListClass());
+        if (relast.listClass != null) {
+          args.add("--listClass=" + relast.listClass);
         }
-        if (isSet(getSerializer())) {
-          args.add("--serializer=" + getSerializer());
+        if (relast.serializer != null) {
+          args.add("--serializer=" + relast.serializer);
         }
-        args.add("--grammarName=" + pathToAbsoluteProject(getGrammarName()));
-        if (isVerbose()) {
+        args.add("--grammarName=" + pathToAbsoluteProject(relast.grammarName));
+        if (relast.verbose) {
           System.out.println("Start relast with args: " + args);
         }
         javaExecSpec.args(args);
       }).assertNormalExitValue();
     });
-    if (isRunJastAdd()) {
-      if (isVerbose()) {
+    if (jastadd.run) {
+      if (relast.verbose) {
         System.out.println("Compile with JastAdd");
       }
       // check which files were actually generated
@@ -290,15 +128,15 @@ public class RelastTest extends DefaultTask {
           javaExecSpec.setClasspath(runtimeClasspath);
           javaExecSpec.setMain("org.jastadd.JastAdd");
           List<Object> args = new ArrayList<>();
-          args.add("--o=" + pathToAbsoluteProject(getOutputDir()));
-          args.add("--package=" + getPackageName());
-          if (isSet(getJastAddList())) {
-            args.add("--List=" + getJastAddList());
+          args.add("--o=" + pathToAbsoluteProject(jastadd.outputDir.getName()));
+          args.add("--package=" + jastadd.packageName);
+          if (jastadd.jastAddList != null) {
+            args.add("--List=" + jastadd.jastAddList);
           }
-          args.addAll(getExtraJastAddOptions());
+          args.addAll(jastadd.extraOptions);
           args.addAll(genFiles);
-          args.addAll(getMoreInputFiles().stream().map(this::pathToAbsoluteProject).collect(Collectors.toList()));
-          if (isVerbose()) {
+          args.addAll(jastadd.inputFiles);
+          if (relast.verbose) {
             System.out.println("Start JastAdd with args: " + args);
           }
           javaExecSpec.args(args);
@@ -307,14 +145,9 @@ public class RelastTest extends DefaultTask {
     }
   }
 
-  private String fileExtension(String filename) {
-    int indexOfDot = filename.lastIndexOf('.');
-    return indexOfDot == -1 ? filename : filename.substring(indexOfDot + 1);
-  }
-
   private boolean verboseFileNotExists(Path path) {
     boolean fileDoesNotExist = !Files.exists(path);
-    if (fileDoesNotExist && isVerbose()) {
+    if (fileDoesNotExist && relast.verbose) {
       System.out.println("Do not include " + path);
     }
     return fileDoesNotExist;
@@ -324,7 +157,7 @@ public class RelastTest extends DefaultTask {
     if (Files.exists(path) && Files.isDirectory(path)) {
       return;
     }
-    if (isVerbose()) {
+    if (relast.verbose) {
       System.out.println("Creating " + path.toAbsolutePath());
     }
     try {