Replacing ragconnect parts with ragconnect jar file.

.gitlab-ci.yml

 variables:
   GIT_SUBMODULE_STRATEGY: recursive
 
-services:
-  - name: "eclipse-mosquitto:1.6.9"
-    alias: "mqtt"
-
 stages:
   - build
-  - test
 
 build:
   image: openjdk:8
   stage: build
-  before_script:
-    - ls -lah *
   script:
     - ./gradlew assemble
-
-test:
-  image: openjdk:8
-  stage: test
-  script:
-    - ./gradlew allTests
-  artifacts:
-    reports:
-      junit: ros2rag.tests/build/test-results/test/TEST-*.xml

.gitmodules

-[submodule "relast-preprocessor"]
-	path = relast.preprocessor
-	url = ../relast-preprocessor.git

buildSrc/.gitignore

-build/

buildSrc/src/main/java/org/jastadd/relast/plugin/CompilerLocationExtension.java

-package org.jastadd.relast.plugin;
-
-import org.gradle.api.Project;
-import org.gradle.api.provider.Property;
-
-/**
- * TODO: Add description.
- *
- * @author rschoene - Initial contribution
- */
-public class CompilerLocationExtension {
-  public Property<String> compilerLocation;
-
-  public CompilerLocationExtension(Project project) {
-    compilerLocation = project.getObjects().property(String.class);
-  }
-
-  public Property<String> getCompilerLocation() {
-    return compilerLocation;
-  }
-}

buildSrc/src/main/java/org/jastadd/relast/plugin/RelastPlugin.java

-package org.jastadd.relast.plugin;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.Task;
-import org.gradle.api.tasks.TaskCollection;
-
-import java.util.Set;
-
-/**
- * Plugin for RelAst-Test.
- *
- * @author rschoene - Initial contribution
- */
-public class RelastPlugin implements Plugin<Project> {
-
-  private Task testTask;
-
-  @Override
-  public void apply(Project project) {
-    CompilerLocationExtension extension = project.getExtensions().create(
-        "relastTest",
-        CompilerLocationExtension.class,
-        project);
-
-    Set<Task> tasks = project.getTasksByName("test", false);
-    // there should be only one task "test"
-    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()));
-  }
-
-  private void setupRelastTest(RelastTest relastTest, String compilerLocation) {
-    testTask.dependsOn(relastTest);
-    relastTest.setCompilerLocation(compilerLocation);
-    relastTest.setGroup("verification");
-  }
-}

buildSrc/src/main/java/org/jastadd/relast/plugin/RelastTest.java

-package org.jastadd.relast.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.SourceSet;
-import org.gradle.api.tasks.SourceSetContainer;
-import org.gradle.api.tasks.TaskAction;
-
-import java.io.IOException;
-import java.nio.file.*;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * RelAst Test Task
- *
- * @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<>();
-
-  public void setCompilerLocation(String compilerLocation) {
-    this.compilerLocation = compilerLocation;
-  }
-
-  public boolean isVerbose() {
-    return verbose;
-  }
-
-  public void setVerbose(boolean verbose) {
-    this.verbose = verbose;
-  }
-
-  // pre-process options
-  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);
-  }
-
-  public boolean isUseJastAddNames() {
-    return useJastAddNames;
-  }
-
-  public void setUseJastAddNames(boolean useJastAddNames) {
-    this.useJastAddNames = useJastAddNames;
-  }
-
-  public boolean isResolverHelper() {
-    return resolverHelper;
-  }
-
-  public void setResolverHelper(boolean resolverHelper) {
-    this.resolverHelper = resolverHelper;
-  }
-
-  public boolean isWriteToFile() {
-    return writeToFile;
-  }
-
-  public void setWriteToFile(boolean writeToFile) {
-    this.writeToFile = writeToFile;
-  }
-
-  public String getGrammarName() {
-    return grammarName;
-  }
-
-  public void setGrammarName(String grammarName) {
-    this.grammarName = grammarName;
-  }
-
-  public String getListClass() {
-    return listClass;
-  }
-
-  public void setListClass(String listClass) {
-    this.listClass = listClass;
-  }
-
-  public String getJastAddList() {
-    return jastAddList;
-  }
-
-  public void setJastAddList(String jastAddList) {
-    this.jastAddList = jastAddList;
-  }
-
-  public String getSerializer() {
-    return serializer;
-  }
-
-  public void setSerializer(String serializer) {
-    this.serializer = serializer;
-  }
-
-  // compile options
-  public boolean isRunJastAdd() {
-    return runJastAdd;
-  }
-
-  public void setRunJastAdd(boolean runJastAdd) {
-    this.runJastAdd = runJastAdd;
-  }
-
-  public String getOutputDir() {
-    return outputDir;
-  }
-
-  public void setOutputDir(String outputDir) {
-    this.outputDir = outputDir;
-  }
-
-  public String getPackageName() {
-    return packageName;
-  }
-
-  public void setPackageName(String packageName) {
-    this.packageName = packageName;
-  }
-
-  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) {
-    return Paths.get(getProject().getProjectDir().getAbsolutePath(), filename);
-  }
-
-  @TaskAction
-  void runTest() throws IOException {
-    setGroup("verification");
-    setDescription("Runs a relast test");
-    Project project = getProject();
-    String absoluteProjectPath = project.getProjectDir().getAbsolutePath();
-    if (isVerbose()) {
-      System.out.println("Running relast test in " + project.getDisplayName());
-      System.out.println("relast files: " + getRelastFiles());
-      System.out.println("Deleting files");
-    }
-    // first, delete generated files
-    List<Path> genFiles = new ArrayList<>();
-    for (String suffix : genSuffixes) {
-      genFiles.add(pathToAbsoluteProject(getGrammarName() + suffix));
-    }
-    if (isVerbose()) {
-      System.out.println("gen files: " + genFiles);
-    }
-    project.delete(deleteSpec -> {
-      deleteSpec.delete(genFiles);
-      if (isSet(getPackageName())) {
-        deleteSpec.delete(Paths.get(getOutputDir(), getPackageName()));
-      }
-    });
-    // create output directories, if not existing
-    createDirectory(pathToAbsoluteProject(getOutputDir()));
-    createDirectory(pathToAbsoluteProject(getGrammarName()).getParent());
-    if (isVerbose()) {
-      System.out.println("Pre processing, running relast");
-    }
-    // then, run relast pre processing
-    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 (compilerLocation != null) {
-          javaExecSpec.setMain("-jar");
-          args.add(compilerLocation);
-        } else {
-          javaExecSpec.setMain("org.jastadd.relast.compiler.Compiler");
-        }
-        args.addAll(getRelastFiles().stream().map(this::pathToAbsoluteProject).collect(Collectors.toList()));
-        args.add("--quiet");
-        if (isWriteToFile()) {
-          args.add("--file");
-        }
-        if (isUseJastAddNames()) {
-          args.add("--useJastAddNames");
-        }
-        if (isResolverHelper()) {
-          args.add("--resolverHelper");
-        }
-        if (isSet(getJastAddList())) {
-          args.add("--jastAddList=" + getJastAddList());
-        }
-        if (isSet(getListClass())) {
-          args.add("--listClass=" + getListClass());
-        }
-        if (isSet(getSerializer())) {
-          args.add("--serializer=" + getSerializer());
-        }
-        args.add("--grammarName=" + pathToAbsoluteProject(getGrammarName()));
-        if (isVerbose()) {
-          System.out.println("Start relast with args: " + args);
-        }
-        javaExecSpec.args(args);
-      }).assertNormalExitValue();
-    });
-    if (isRunJastAdd()) {
-      if (isVerbose()) {
-        System.out.println("Compile with JastAdd");
-      }
-      // check which files were actually generated
-      genFiles.removeIf(this::verboseFileNotExists);
-      // finally, compile generated files
-      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 -> {
-          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.addAll(genFiles);
-          args.addAll(getMoreInputFiles().stream().map(this::pathToAbsoluteProject).collect(Collectors.toList()));
-          if (isVerbose()) {
-            System.out.println("Start JastAdd with args: " + args);
-          }
-          javaExecSpec.args(args);
-        });
-      });
-    }
-  }
-
-  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()) {
-      System.out.println("Do not include " + path);
-    }
-    return fileDoesNotExist;
-  }
-
-  private void createDirectory(Path path) throws IOException {
-    if (Files.exists(path) && Files.isDirectory(path)) {
-      return;
-    }
-    if (isVerbose()) {
-      System.out.println("Creating " + path.toAbsolutePath());
-    }
-    try {
-      Files.createDirectories(path);
-    } catch (FileAlreadyExistsException e) {
-      System.err.println("Skipping creation of already existing " + path);
-    } catch (IOException e) {
-      System.err.println("Could not create output directory " + path);
-      throw e;
-    }
-  }
-
-}

buildSrc/src/main/resources/META-INF/gradle-plugins/org.jastadd.relast.plugin.properties

-implementation-class=org.jastadd.relast.plugin.RelastPlugin

ragconnect.base/.gitignore

-build
-src/gen-res/
-src/gen/
-out/
-*.class

ragconnect.base/build.gradle

-apply plugin: 'jastadd'
-apply plugin: 'application'
-
-sourceCompatibility = 1.8
-
-mainClassName = 'org.jastadd.ragconnect.compiler.Compiler'
-
-repositories {
-    jcenter()
-}
-
-buildscript {
-    repositories.jcenter()
-    dependencies {
-        classpath 'org.jastadd:jastaddgradle:1.13.3'
-    }
-}
-
-dependencies {
-    implementation project(':relast.preprocessor')
-    implementation group: 'com.github.spullara.mustache.java', name: 'compiler', version: '0.9.6'
-    implementation group: 'org.apache.logging.log4j', name: 'log4j-jul', version: '2.11.2'
-    runtime group: 'org.jastadd', name: 'jastadd', version: '2.3.4'
-    api group: 'net.sf.beaver', name: 'beaver-rt', version: '0.9.11'
-}
-
-def versionFile = 'src/main/resources/ragConnectVersion.properties'
-def oldProps = new Properties()
-
-try {
-    file(versionFile).withInputStream { stream -> oldProps.load(stream) }
-    version = oldProps['version']
-} catch (e) {
-    // this happens, if either the properties file is not present, or cannot be read from
-    throw new GradleException("File ${versionFile} not found or unreadable. Aborting.", e)
-}
-
-task newVersion() {
-    doFirst {
-        def props = new Properties()
-        props['version'] = value
-        props.store(file(versionFile).newWriter(), null)
-    }
-}
-
-sourceSets {
-    main {
-        java.srcDir "src/gen/java"
-    }
-}
-
-test {
-    useJUnitPlatform()
-
-    maxHeapSize = '1G'
-}
-
-jar {
-    manifest {
-        attributes "Main-Class": 'org.jastadd.ragconnect.compiler.Compiler'
-    }
-
-    from {
-        configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
-    }
-}
-
-task relast(type: JavaExec) {
-    group = 'Build'
-    main = "-jar"
-
-    args = [
-            "../libs/relast.jar",
-            "../relast.preprocessor/src/main/jastadd/RelAst.relast",
-            "./src/main/jastadd/RagConnect.relast",
-            "./src/main/jastadd/MustacheNodes.relast",
-            "./src/main/jastadd/YAML.relast",
-            "--listClass=java.util.ArrayList",
-            "--jastAddList=JastAddList",
-            "--useJastAddNames",
-            "--file",
-            "--resolverHelper",
-            "--grammarName=./src/gen/jastadd/RagConnect"
-    ]
-
-    inputs.files("../libs/relast.jar",
-            "../relast.preprocessor/src/main/jastadd/RelAst.relast",
-            "./src/main/jastadd/RagConnect.relast",
-            "./src/main/jastadd/MustacheNodes.relast",
-            "./src/main/jastadd/YAML.relast")
-    outputs.files("./src/gen/jastadd/RagConnect.ast",
-            "./src/gen/jastadd/RagConnect.jadd",
-            "./src/gen/jastadd/RagConnectRefResolver.jadd",
-            './src/gen/jastadd/RagConnectResolverStubs.jrag')
-}
-
-jastadd {
-    configureModuleBuild()
-    modules {
-        //noinspection GroovyAssignabilityCheck
-        module("RagConnect") {
-
-            java {
-                basedir ".."
-                include "relast.preprocessor/main/**/*.java"
-                include "relast.preprocessor/gen/**/*.java"
-                include "ragconnect.base/src/main/**/*.java"
-                include "ragconnect.base/src/gen/**/*.java"
-            }
-
-            jastadd {
-                basedir ".."
-                include "relast.preprocessor/src/main/jastadd/**/*.ast"
-                include "relast.preprocessor/src/main/jastadd/**/*.jadd"
-                include "relast.preprocessor/src/main/jastadd/**/*.jrag"
-                include "ragconnect.base/src/main/jastadd/**/*.ast"
-                include "ragconnect.base/src/main/jastadd/**/*.jadd"
-                include "ragconnect.base/src/main/jastadd/**/*.jrag"
-                include "ragconnect.base/src/gen/jastadd/**/*.ast"
-                include "ragconnect.base/src/gen/jastadd/**/*.jadd"
-                include "ragconnect.base/src/gen/jastadd/**/*.jrag"
-            }
-
-            scanner {
-                basedir ".."
-                include "ragconnect.base/src/main/jastadd/scanner/Header.flex",               [-5]
-                include "relast.preprocessor/src/main/jastadd/scanner/Preamble.flex",      [-4]
-                include "relast.preprocessor/src/main/jastadd/scanner/Macros.flex",        [-3]
-                include "ragconnect.base/src/main/jastadd/scanner/Macros.flex",               [-3]
-                include "relast.preprocessor/src/main/jastadd/scanner/RulesPreamble.flex", [-2]
-                include "ragconnect.base/src/main/jastadd/scanner/MappingContent.flex",       [-1]
-                include "ragconnect.base/src/main/jastadd/scanner/Keywords.flex"
-                include "relast.preprocessor/src/main/jastadd/scanner/Keywords.flex"
-                include "relast.preprocessor/src/main/jastadd/scanner/Symbols.flex",        [1]
-                include "relast.preprocessor/src/main/jastadd/scanner/RulesPostamble.flex", [2]
-            }
-
-            parser {
-                basedir ".."
-                include "ragconnect.base/src/main/jastadd/parser/Preamble.parser"
-                include "ragconnect.base/src/main/jastadd/parser/RagConnect.parser"
-                include "relast.preprocessor/src/main/jastadd/parser/RelAst.parser"
-            }
-        }
-    }
-
-    cleanGen.doFirst {
-        delete "src/gen/java/org"
-        delete "src/gen-res/BuildInfo.properties"
-    }
-
-    preprocessParser.doFirst {
-
-        args += ["--no-beaver-symbol"]
-
-    }
-
-    module = "RagConnect"
-
-    astPackage = 'org.jastadd.ragconnect.ast'
-
-    parser.name = 'RagConnectParser'
-
-    genDir = 'src/gen/java'
-
-    buildInfoDir = 'src/gen-res'
-
-    scanner.genDir = "src/gen/java/org/jastadd/ragconnect/scanner"
-    parser.genDir = "src/gen/java/org/jastadd/ragconnect/parser"
-
-    jastaddOptions = ["--lineColumnNumbers", "--List=JastAddList", "--safeLazy", "--visitCheck=true", "--rewrite=cnta", "--cache=all"]
-}
-
-generateAst.dependsOn relast

ragconnect.base/src/main/jastadd/Analysis.jrag

-aspect Analysis {
-  // --- lookupTokenEndpointDefinition ---
-  inh java.util.List<TokenEndpointDefinition> TokenEndpointDefinition.lookupTokenEndpointDefinitions(TokenComponent token);
-  eq RagConnect.getEndpointDefinition().lookupTokenEndpointDefinitions(TokenComponent token) = lookupTokenEndpointDefinitions(token);
-  syn java.util.List<TokenEndpointDefinition> RagConnect.lookupTokenEndpointDefinitions(TokenComponent token) {
-    java.util.List<TokenEndpointDefinition> result = new java.util.ArrayList<>();
-    for (EndpointDefinition def : getEndpointDefinitionList()) {
-      if (def.isTokenEndpointDefinition() && def.asTokenEndpointDefinition().getToken().equals(token)) {
-        result.add(def.asTokenEndpointDefinition());
-      }
-    }
-    return result;
-  }
-
-  // --- lookupDependencyDefinition ---
-  inh DependencyDefinition DependencyDefinition.lookupDependencyDefinition(TypeDecl source, String id);
-  eq RagConnect.getDependencyDefinition().lookupDependencyDefinition(TypeDecl source, String id) {
-    for (DependencyDefinition def : getDependencyDefinitionList()) {
-      if (def.getID().equals(id) && def.getSource().containingTypeDecl().equals(source)) {
-        return def;
-      }
-    }
-    return null;
-  }
-
-  // --- isAlreadyDefined ---
-  syn boolean TokenEndpointDefinition.isAlreadyDefined() = lookupTokenEndpointDefinitions(getToken()).size() > 1;
-  syn boolean DependencyDefinition.isAlreadyDefined() = lookupDependencyDefinition(getSource().containingTypeDecl(), getID()) != this;
-
-  syn boolean MappingDefinitionType.assignableTo(JavaTypeUse target);
-  eq JavaMappingDefinitionType.assignableTo(JavaTypeUse target) = getType().assignableTo(target);
-  eq JavaArrayMappingDefinitionType.assignableTo(JavaTypeUse target) {
-    if (!target.getName().endsWith("[]")) { return false; }
-    return getType().assignableTo(new SimpleJavaTypeUse(target.getName().replace("[]", "")));
-  }
-  syn boolean JavaTypeUse.assignableTo(JavaTypeUse target) {
-    // target var = this;
-    return target.primitivePrettyPrint().equals(this.primitivePrettyPrint());
-  }
-  syn String JavaTypeUse.primitivePrettyPrint() {
-    switch(getName()) {
-      case "int":
-      case "Integer": return "int";
-      case "short":
-      case "Short": return "short";
-      case "long":
-      case "Long": return "long";
-      case "float":
-      case "Float": return "float";
-      case "double":
-      case "Double": return "double";
-      case "char":
-      case "Character": return "char";
-      default: return getName();
-    }
-  }
-}

ragconnect.base/src/main/jastadd/Errors.jrag

-import java.util.Set;
-import java.util.TreeSet;
-import java.util.LinkedList;
-
-aspect Errors {
-  coll Set<ErrorMessage> RagConnect.errors()
-    [new TreeSet<ErrorMessage>()]
-    root RagConnect;
-
-    ReceiveTokenEndpointDefinition contributes error("Receive definition already defined for " + getToken().getName())
-      when isAlreadyDefined()
-      to RagConnect.errors();
-
-    ReceiveTokenEndpointDefinition contributes error("Receiving target token must not be an NTA token!")
-      when getToken().getNTA()
-      to RagConnect.errors();
-
-    // if first mapping is null, then suitableDefaultMapping() == null
-    ReceiveTokenEndpointDefinition contributes error("No suitable default mapping found for type " +
-      ((getMappingList().isEmpty())
-        ? getToken().effectiveJavaTypeUse().prettyPrint()
-        : getMappingList().get(0).getFromType().prettyPrint()))
-      when effectiveMappings().get(0) == null
-      to RagConnect.errors();
-
-    ReceiveTokenEndpointDefinition contributes error("to-type of last mapping (" + effectiveMappings().get(effectiveMappings().size() - 1).getToType().prettyPrint() + ") not assignable to type of the Token (" + getToken().effectiveJavaTypeUse().prettyPrint() + ")!")
-      when !effectiveMappings().get(effectiveMappings().size() - 1).getToType().assignableTo(
-          getToken().effectiveJavaTypeUse())
-      to RagConnect.errors();
-
-    SendTokenEndpointDefinition contributes error("Sending target token must be an NTA token!")
-      when !getToken().getNTA()
-      to RagConnect.errors();
-
-    SendTokenEndpointDefinition contributes error("Send definition already defined for " + getToken().getName())
-      when isAlreadyDefined()
-      to RagConnect.errors();
-
-    DependencyDefinition contributes error("Dependency definition already defined for " + getSource().containingTypeDecl().getName() + " with name " + getID())
-      when isAlreadyDefined()
-      to RagConnect.errors();
-
-    DependencyDefinition contributes error("The name of a dependency definition must not be equal to a list-node on the source")
-      when isAlreadyDefinedAsList()
-      to RagConnect.errors();
-
-    DependencyDefinition contributes error("There must be a send endpoint definition targeting " + getSource().parentTypeypeAndName() + " for dependency definition " + getID())
-      when targetEndpointDefinition() == null
-      to RagConnect.errors();
-}
-
-aspect ErrorHelpers {
-  syn boolean DependencyDefinition.isAlreadyDefinedAsList() {
-    for (Component comp : getSource().containingTypeDecl().getComponentList()) {
-      if (comp.isListComponent() && comp.getName().equals(this.getID())) {
-        return true;
-      }
-    }
-    return false;
-  }
-  syn String TokenComponent.parentTypeypeAndName() = containingTypeDecl().getName() + "." + getName();
-}
-
-aspect ErrorMessage {
-  public class ErrorMessage implements Comparable<ErrorMessage> {
-    private final ASTNode node;
-    private final String filename;
-    private final int line;
-    private final int col;
-    private final String message;
-
-    public ErrorMessage(ASTNode node, String message) {
-      this.node = node;
-      this.filename = node.containedFileName();
-      this.line = node.getStartLine();
-      this.col = node.getStartColumn();
-      this.message = message;
-    }
-
-    public ASTNode getNode() {
-      return node;
-    }
-    public int getLine() {
-      return line;
-    }
-    public int getCol() {
-      return col;
-    }
-    public String getMessage() {
-      return message;
-    }
-
-    public String toString() {
-      return filename + " Line " + line + ", column " + col + ": " + message;
-    }
-
-    @Override
-    public int compareTo(ErrorMessage err) {
-      int n = filename.compareTo(err.filename);
-      if (n != 0) {
-        return n;
-      }
-
-      n = line - err.line;
-      if (n != 0) {
-        return n;
-      }
-
-      n = col-err.col;
-      if (n != 0) {
-        return n;
-      }
-
-      return message.compareTo(err.message);
-    }
-  }
-
-  protected ErrorMessage ASTNode.error(String message) {
-    return new ErrorMessage(this, message);
-  }
-}

ragconnect.base/src/main/jastadd/MustacheNodes.relast

-MRagConnect ::= ReceiveDefinition:MReceiveDefinition* SendDefinition:MSendDefinition* MappingDefinition:MMappingDefinition* DependencyDefinition:MDependencyDefinition* RootTypeComponent:MTypeComponent* TokenComponent:MTokenComponent*;
-abstract MEndpointDefinition ::= InnerMappingDefinition:MInnerMappingDefinition*;
-MReceiveDefinition : MEndpointDefinition;
-MSendDefinition : MEndpointDefinition;
-MMappingDefinition;
-MInnerMappingDefinition;
-MDependencyDefinition;
-MTypeComponent;
-MTokenComponent;
-
-rel MRagConnect.RagConnect -> RagConnect;
-rel MInnerMappingDefinition.MMappingDefinition -> MMappingDefinition;
-rel MReceiveDefinition.ReceiveTokenEndpointDefinition -> ReceiveTokenEndpointDefinition;
-rel MSendDefinition.SendTokenEndpointDefinition -> SendTokenEndpointDefinition;
-rel MMappingDefinition.MappingDefinition -> MappingDefinition;
-rel MDependencyDefinition.DependencyDefinition -> DependencyDefinition;
-rel MTypeComponent.TypeComponent -> TypeComponent;
-rel MTokenComponent.TokenComponent -> TokenComponent;
-rel MTokenComponent.DependencyDefinition* -> MDependencyDefinition;

ragconnect.base/src/main/jastadd/NameResolution.jrag

-aspect NameResolution {
-
-  refine RefResolverStubs eq EndpointDefinition.resolveMappingByToken(String id, int position) {
-    // return a MappingDefinition
-    for (MappingDefinition mappingDefinition : ragconnect().getMappingDefinitionList()) {
-      if (mappingDefinition.getID().equals(id)) {
-        return mappingDefinition;
-      }
-    }
-    System.err.println("Could not resolve MappingDefinition '" + id + "'.");
-    return null;
-  }
-
-}

ragconnect.base/src/main/jastadd/Navigation.jrag

-aspect Navigation {
-
-  // --- program ---
-  eq RagConnect.getChild().program() = getProgram();
-  eq MRagConnect.getChild().program() = getRagConnect().program();
-
-  // --- ragconnect ---
-  inh RagConnect ASTNode.ragconnect();
-  eq RagConnect.getChild().ragconnect() = this;
-  eq MRagConnect.getChild().ragconnect() = getRagConnect();
-
-  // --- containedFile
-  eq Grammar.getChild().containedFile() = null;
-  eq RagConnect.getChild().containedFile() = null;
-  eq MRagConnect.getChild().containedFile() = null;
-
-  // --- containedFileName ---
-  eq Grammar.getChild().containedFileName() = null;  // should be in PP
-  eq RagConnect.getChild().containedFileName() = getFileName();
-  eq MRagConnect.getChild().containedFileName() = null;
-
-  // --- isTokenEndpointDefinition ---
-  syn boolean EndpointDefinition.isTokenEndpointDefinition() = false;
-  eq TokenEndpointDefinition.isTokenEndpointDefinition() = true;
-
-  // --- asTokenEndpointDefinition ---
-  syn TokenEndpointDefinition EndpointDefinition.asTokenEndpointDefinition() = null;
-  eq TokenEndpointDefinition.asTokenEndpointDefinition() = this;
-
-  // --- isSendTokenEndpointDefinition ---
-  syn boolean EndpointDefinition.isSendTokenEndpointDefinition() = false;
-  eq SendTokenEndpointDefinition.isSendTokenEndpointDefinition() = true;
-
-  // --- asSendTokenEndpointDefinition ---
-  syn SendTokenEndpointDefinition EndpointDefinition.asSendTokenEndpointDefinition() = null;
-  eq SendTokenEndpointDefinition.asSendTokenEndpointDefinition() = this;
-
-  // --- asReceiveTokenEndpointDefinition ---
-  syn ReceiveTokenEndpointDefinition EndpointDefinition.asReceiveTokenEndpointDefinition() = null;
-  eq ReceiveTokenEndpointDefinition.asReceiveTokenEndpointDefinition() = this;
-
-  // --- targetEndpointDefinition ---
-  syn SendTokenEndpointDefinition DependencyDefinition.targetEndpointDefinition() {
-    // resolve definition in here, as we do not need resolveMethod in any other place (yet)
-    for (EndpointDefinition endpointDefinition : ragconnect().getEndpointDefinitionList()) {
-      if (endpointDefinition.isSendTokenEndpointDefinition() &&
-          endpointDefinition.asSendTokenEndpointDefinition().getToken().equals(this.getTarget())) {
-        return endpointDefinition.asSendTokenEndpointDefinition();
-      }
-    }
-    return null;
-  }
-
-  // --- effectiveJavaTypeUse (should be in preprocessor) ---
-  syn lazy JavaTypeUse TokenComponent.effectiveJavaTypeUse() = hasJavaTypeUse() ? getJavaTypeUse() : new SimpleJavaTypeUse("String");
-
-  // --- isDefaultMappingDefinition ---
-  syn boolean MappingDefinition.isDefaultMappingDefinition() = false;
-  eq DefaultMappingDefinition.isDefaultMappingDefinition() = true;
-}

ragconnect.base/src/main/jastadd/Printing.jrag

-aspect Printing {
-  String ASTNode.PRINT_INDENT = "  ";
-
-  syn String MappingDefinitionType.prettyPrint();
-  eq JavaMappingDefinitionType.prettyPrint() = getType().getName();
-  eq JavaArrayMappingDefinitionType.prettyPrint() = getType().getName() + "[]";
-
-  syn String JavaTypeUse.prettyPrint() {
-    StringBuilder sb = new StringBuilder();
-    generateAbstractGrammar(sb);
-    return sb.toString();
-  }
-
-  syn String Document.prettyPrint() {
-    StringBuilder sb = new StringBuilder();
-    sb.append("# RagConnect created at ").append(java.time.Instant.now()).append("\n");
-    for (ComplexElement element : getComplexElementList()) {
-      element.prettyPrint(sb, false, "");
-    }
-    if (sb.charAt(sb.length() - 1) != '\n') {
-      sb.append("\n");
-    }
-    return sb.toString();
-  }
-  syn StringBuilder Element.prettyPrint(StringBuilder sb, boolean printIndent, String indent);
-  eq ValueElement.prettyPrint(StringBuilder sb, boolean printIndent, String indent) {
-    sb.append(getValue());
-    return sb;
-  }
-  eq StringElement.prettyPrint(StringBuilder sb, boolean printIndent, String indent) {
-    sb.append("\"").append(getValue()).append("\"");
-    return sb;
-  }
-  eq ListElement.prettyPrint(StringBuilder sb, boolean printIndent, String indent) {
-    if (isEmpty()) {
-      sb.append("[]");
-    } else {
-      for (Element element : getElementList()) {
-        sb.append(indent).append("- ");
-        element.prettyPrint(sb, false, indent + PRINT_INDENT);
-        sb.append("\n");
-      }
-      // delete last newline
-      sb.deleteCharAt(sb.length() - 1);
-    }
-    return sb;
-  }
-  eq KeyValuePair.prettyPrint(StringBuilder sb, boolean printIndent, String indent) {
-    if (printIndent) sb.append(indent);
-    sb.append(getKey()).append(": ");
-    if (getValue().isComplex() && !getValue().isEmpty()) {
-      sb.append("\n");
-      getValue().prettyPrint(sb, true, indent + PRINT_INDENT);  //);
-    } else {
-      getValue().prettyPrint(sb, false, indent);
-    }
-    return sb;
-  }
-  eq MappingElement.prettyPrint(StringBuilder sb, boolean printIndent, String indent) {
-    if (isEmpty()) {
-      sb.append("{}");
-    } else {
-      boolean first = true;
-      for (KeyValuePair pair : getKeyValuePairList()) {
-        if (!first || printIndent) sb.append(indent);
-        first = false;
-        pair.prettyPrint(sb, false, indent);  // + PRINT_INDENT
-        sb.append("\n");
-      }
-      // delete last newline
-      sb.deleteCharAt(sb.length() - 1);
-    }
-    return sb;
-  }
-}

ragconnect.base/src/main/jastadd/RagConnect.relast

-RagConnect ::= EndpointDefinition* DependencyDefinition* MappingDefinition* Program <FileName> ;
-
-abstract EndpointDefinition ::= <AlwaysApply:boolean> ;
-
-rel EndpointDefinition.Mapping* <-> MappingDefinition.UsedAt*;
-
-abstract TokenEndpointDefinition : EndpointDefinition;
-rel TokenEndpointDefinition.Token -> TokenComponent;
-
-ReceiveTokenEndpointDefinition : TokenEndpointDefinition;
-SendTokenEndpointDefinition : TokenEndpointDefinition;
-
-DependencyDefinition ::= <ID>;
-rel DependencyDefinition.Source <-> TokenComponent.DependencySourceDefinition*;
-rel DependencyDefinition.Target -> TokenComponent;
-
-MappingDefinition ::= <ID> FromType:MappingDefinitionType <FromVariableName> ToType:MappingDefinitionType <Content> ;
-abstract MappingDefinitionType ::= ;
-JavaMappingDefinitionType : MappingDefinitionType ::= Type:JavaTypeUse ;
-JavaArrayMappingDefinitionType : MappingDefinitionType ::= Type:JavaTypeUse ;
-DefaultMappingDefinition : MappingDefinition ;

ragconnect.base/src/main/jastadd/Util.jadd

-aspect Util {
-  static String ASTNode.capitalize(String s) {
-    return Character.toUpperCase(s.charAt(0)) + s.substring(1);
-  }
-}

ragconnect.base/src/main/jastadd/YAML.jrag

-aspect Navigation {
-  eq Document.getChild().program() = null;
-  eq Document.getChild().ragconnect() = null;
-  eq Document.getChild().containedFile() = null;
-  eq Document.getChild().containedFileName() = getFileName();
-
-  syn boolean Element.isComplex() = false;
-  eq ComplexElement.isComplex() = true;
-
-  syn boolean Element.isEmpty() = false;
-  eq MappingElement.isEmpty() = getNumKeyValuePair() == 0;
-  eq ListElement.isEmpty() = getNumElement() == 0;
-}
-
-aspect Helper {
-  public static ValueElement ValueElement.of(int value) {
-    return new ValueElement(String.valueOf(value));
-  }
-  public static ValueElement ValueElement.of(boolean value) {
-    return new ValueElement(String.valueOf(value));
-  }
-  public static ValueElement ValueElement.of(String value) {
-    return new ValueElement(value);
-  }
-  public static StringElement StringElement.of(String value) {
-    return new StringElement(value);
-  }
-  public void MappingElement.addKeyValuePair(String key, Element value) {
-    addKeyValuePair(new KeyValuePair(key, value));
-  }
-}

ragconnect.base/src/main/jastadd/YAML.relast

-Document ::= <FileName> ComplexElement* ;
-abstract Element ;
-abstract ComplexElement : Element ;
-MappingElement : ComplexElement ::= KeyValuePair* ;
-KeyValuePair : ComplexElement ::= <Key> Value:Element ;
-ListElement : ComplexElement ::= Element* ;
-abstract SimpleElement : Element ;
-ValueElement : SimpleElement ::= <Value> ;
-StringElement : SimpleElement ::= <Value> ;