WIP dumpAst 0.3.1

- changed package names to de.tudresden.inf.st.*
- begin with tests
- fixed some bugs while testing

testDumper/.gitignore

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

testDumper/build.gradle

+apply plugin: 'jastadd'
+apply plugin: 'idea'
+
+repositories {
+    mavenCentral()
+}
+
+buildscript {
+    repositories.jcenter()
+    dependencies {
+        classpath 'org.jastadd:jastaddgradle:1.13.3'
+    }
+}
+
+dependencies {
+    runtime group: 'org.jastadd', name: 'jastadd', version: '2.3.4'
+
+    testImplementation project(':dumpAst')
+    testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.4.0'
+    testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.4.0'
+    testImplementation group: 'org.assertj', name: 'assertj-core', version: '3.12.1'
+}
+
+File genSrc = file("src/gen/java")
+sourceSets.main.java.srcDir genSrc
+idea.module.generatedSourceDirs += genSrc
+
+test {
+    useJUnitPlatform()
+
+    maxHeapSize = '1G'
+}
+
+File testingGrammar = file('./src/main/jastadd/testDumper.relast')
+
+task relast(type: JavaExec) {
+    group = 'Build'
+    main = "-jar"
+
+    doFirst {
+        delete "src/gen/jastadd/*.ast"
+        delete "src/gen/jastadd/testDumper.jadd"
+        delete "src/gen/jastadd/testDumperRefResolver.jadd"
+        delete "src/gen/jastadd/testDumperResolverStubs.jrag"
+        mkdir  "src/gen/jastadd/"
+    }
+
+    args = [
+            "../libs/relast.jar",
+            testingGrammar,
+//            "./src/main/jastadd/MustacheNodes.relast",
+            "--listClass=java.util.ArrayList",
+            "--jastAddList=JastAddList",
+            "--useJastAddNames",
+            "--file",
+            "--resolverHelper",
+            "--grammarName=./src/gen/jastadd/testDumper"
+    ]
+
+    inputs.files(file("../libs/relast.jar"),
+            testingGrammar)
+    outputs.files(file("./src/gen/jastadd/testDumper.ast"),
+            file("./src/gen/jastadd/testDumper.jadd"),
+            file("./src/gen/jastadd/testDumperRefResolver.jadd"),
+            file('./src/gen/jastadd/testDumperResolverStubs.jrag'))
+}
+
+jastadd {
+    configureModuleBuild()
+    modules {
+        //noinspection GroovyAssignabilityCheck
+        module("testDumper") {
+
+            java {
+                basedir ".."
+                include "testDumper/src/main/**/*.java"
+                include "testDumper/src/gen/**/*.java"
+            }
+
+            jastadd {
+                basedir ".."
+                include "testDumper/src/main/jastadd/**/*.ast"
+                include "testDumper/src/main/jastadd/**/*.jadd"
+                include "testDumper/src/main/jastadd/**/*.jrag"
+                include "testDumper/src/gen/jastadd/**/*.ast"
+                include "testDumper/src/gen/jastadd/**/*.jadd"
+                include "testDumper/src/gen/jastadd/**/*.jrag"
+            }
+        }
+    }
+
+    cleanGen.doFirst {
+        delete "src/gen/java/org"
+        delete "src/gen-res/BuildInfo.properties"
+    }
+
+    preprocessParser.doFirst {
+
+        args += ["--no-beaver-symbol"]
+
+    }
+
+    module = "testDumper"
+    astPackage = 'org.jastadd.testDumper.ast'
+    genDir = 'src/gen/java'
+    buildInfoDir = 'src/gen-res'
+    jastaddOptions = ["--lineColumnNumbers", "--List=JastAddList", "--safeLazy", "--visitCheck=true", "--rewrite=cnta", "--cache=all"]
+}
+
+generateAst.dependsOn relast

testDumper/src/main/jastadd/testDumper.jrag

+aspect Grammar {
+  syn A C.getCalculated() {
+    A result = new A();
+    result.setName("Calculated-" + getName());
+    return result;
+  }
+
+  syn JastAddList<B> C.getAlsoCalculatedList() {
+    JastAddList<B> result = new JastAddList<>();
+    B inner = new B();
+    inner.setName("AlsoCalculated-" + getName());
+    result.add(inner);
+    return result;
+  }
+
+  syn nta A C.getCalculatedNewSyntax() {
+    A result = new A();
+    result.setName("Calculated-" + getName());
+    return result;
+  }
+
+  syn nta JastAddList<B> C.getAlsoCalculatedListNewSyntax() {
+    JastAddList<B> result = new JastAddList<>();
+    B inner = new B();
+    inner.setName("AlsoCalculated-" + getName());
+    result.add(inner);
+    return result;
+  }
+}

testDumper/src/main/jastadd/testDumper.relast

+Nameable ::= <Name> ;
+Root : Nameable ::= A B* [C] ;
+A : Nameable ::= B C ;
+B : Nameable ::= ;
+C : Nameable ::= <Unwanted:int> <RawReference:A> /Calculated:A/ /AlsoCalculated:B*/ ;
+
+rel B.oneA -> A ;
+rel B.maybeC? -> C ;
+rel B.manyA* -> A ;
+rel C.biA1 <-> A.biC1 ;
+rel C.biA2* <-> A.biC2 ;
+rel C.biA3? <-> A.biC3 ;

testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java

+package de.tudresden.inf.st.jastadd.testDumper;
+
+import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode;
+import org.jastadd.testDumper.ast.A;
+import org.jastadd.testDumper.ast.B;
+import org.jastadd.testDumper.ast.C;
+import org.jastadd.testDumper.ast.Root;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static de.tudresden.inf.st.jastadd.testDumper.TestUtils.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TestSimple {
+
+  @Test
+  public void testEmpty() {
+    Root root = new Root();
+    root.setName(ROOT_NAME);
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactly(ROOT_NAME);
+    DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
+    assertEquals(1, actualRoot.getNumDumpToken());
+    assertEquals(0, actualRoot.getNumDumpChildNode());
+    assertEquals(0, actualRoot.getNumDumpRelation());
+  }
+
+  @Test
+  public void testOneNormalChild() {
+    Root root = new Root();
+    root.setName(ROOT_NAME);
+    A a = new A();
+    a.setName(A_NAME);
+    root.setA(a);
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(2, nodes.size());
+    assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME);
+    DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
+    assertEquals(1, actualRoot.getNumDumpToken());
+    assertEquals(1, actualRoot.getNumDumpChildNode());
+    assertEquals(0, actualRoot.getNumDumpRelation());
+    List<DumpNode> children = TestUtils.normalChildren(actualRoot);
+    assertThat(children).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME);
+  }
+
+  @Test
+  public void testOneListChild() {
+    Root root = new Root();
+    root.setName(ROOT_NAME);
+    B b = new B();
+    b.setName(B_NAME);
+    root.addB(b);
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(2, nodes.size());
+    assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, B_NAME);
+    DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
+    assertEquals(1, actualRoot.getNumDumpToken());
+    assertEquals(1, actualRoot.getNumDumpChildNode());
+    assertEquals(0, actualRoot.getNumDumpRelation());
+    List<DumpNode> children = TestUtils.listChildren(actualRoot);
+    assertThat(children).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(B_NAME);
+  }
+
+  @Test
+  public void testOneOptChild() {
+    Root root = new Root();
+    root.setName(ROOT_NAME);
+    C c = new C();
+    c.setName(C_NAME);
+    root.setC(c);
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(2, nodes.size());
+    assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, C_NAME);
+    DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
+    assertEquals(1, actualRoot.getNumDumpToken());
+    assertEquals(1, actualRoot.getNumDumpChildNode());
+    assertEquals(0, actualRoot.getNumDumpRelation());
+    List<DumpNode> children = TestUtils.normalChildren(actualRoot);
+    assertThat(children).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(C_NAME);
+  }
+
+  @Test
+  public void testNormalUniRelation() {
+    Root root = relationSetup();
+    root.getB(0).setOneA(root.getA());
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(4, nodes.size());
+    DumpNode actualB = TestUtils.findByName(nodes, B_NAME);
+    assertEquals(1, actualB.getNumDumpRelation());
+    assertEquals("OneA", actualB.getDumpRelation(0).label());
+    List<DumpNode> relationEnds = normalRelationChildren(actualB);
+    assertThat(relationEnds).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME);
+  }
+
+  @Test
+  public void testListUniRelation() {
+    Root root = relationSetup();
+    root.getB(0).addManyA(root.getA());
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(4, nodes.size());
+    DumpNode actualB = TestUtils.findByName(nodes, B_NAME);
+    assertEquals(1, actualB.getNumDumpRelation());
+    assertEquals("ManyA", actualB.getDumpRelation(0).label());
+    List<DumpNode> relationEnds = listRelationChildren(actualB);
+    assertThat(relationEnds).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME);
+  }
+
+  @Test
+  public void testOptUniRelation() {
+    Root root = relationSetup();
+    root.getB(0).setMaybeC(root.getC());
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(4, nodes.size());
+    DumpNode actualB = TestUtils.findByName(nodes, B_NAME);
+    assertEquals(1, actualB.getNumDumpRelation());
+    assertEquals("MaybeC", actualB.getDumpRelation(0).label());
+    List<DumpNode> relationEnds = normalRelationChildren(actualB);
+    assertThat(relationEnds).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(C_NAME);
+  }
+
+  @Test
+  public void testNormalBiRelation() {
+    Root root = relationSetup();
+    root.getC().setBiA1(root.getA());
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(4, nodes.size());
+    // bidirectional relations are currently not found, instead there will be two unidirectional ones
+    DumpNode actualA = TestUtils.findByName(nodes, A_NAME);
+    assertEquals(1, actualA.getNumDumpRelation());
+    assertEquals("BiC1", actualA.getDumpRelation(0).label());
+    List<DumpNode> relationEndsOfA = normalRelationChildren(actualA);
+    assertThat(relationEndsOfA).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(C_NAME);
+    DumpNode actualC = TestUtils.findByName(nodes, C_NAME);
+    assertEquals(1, actualC.getNumDumpRelation());
+    assertEquals("BiA1", actualC.getDumpRelation(0).label());
+    List<DumpNode> relationEndsOfC = normalRelationChildren(actualC);
+    assertThat(relationEndsOfC).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME);
+  }
+
+  @Test
+  public void testListBiRelation() {
+    Root root = relationSetup();
+    root.getC().addBiA2(root.getA());
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(4, nodes.size());
+    // bidirectional relations are currently not found, instead there will be two unidirectional ones
+    DumpNode actualA = TestUtils.findByName(nodes, A_NAME);
+    assertEquals(1, actualA.getNumDumpRelation());
+    assertEquals("BiC2", actualA.getDumpRelation(0).label());
+    List<DumpNode> relationEndsOfA = normalRelationChildren(actualA);
+    assertThat(relationEndsOfA).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(C_NAME);
+    DumpNode actualC = TestUtils.findByName(nodes, C_NAME);
+    assertEquals(1, actualC.getNumDumpRelation());
+    assertEquals("BiA2", actualC.getDumpRelation(0).label());
+    List<DumpNode> relationEndsOfC = listRelationChildren(actualC);
+    assertThat(relationEndsOfC).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME);
+  }
+
+  @Test
+  public void testOptBiRelation() {
+    Root root = relationSetup();
+    root.getC().setBiA3(root.getA());
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(4, nodes.size());
+    // bidirectional relations are currently not found, instead there will be two unidirectional ones
+    DumpNode actualA = TestUtils.findByName(nodes, A_NAME);
+    assertEquals(1, actualA.getNumDumpRelation());
+    assertEquals("BiC3", actualA.getDumpRelation(0).label());
+    List<DumpNode> relationEndsOfA = normalRelationChildren(actualA);
+    assertThat(relationEndsOfA).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(C_NAME);
+    DumpNode actualC = TestUtils.findByName(nodes, C_NAME);
+    assertEquals(1, actualC.getNumDumpRelation());
+    assertEquals("BiA3", actualC.getDumpRelation(0).label());
+    List<DumpNode> relationEndsOfC = normalRelationChildren(actualC);
+    assertThat(relationEndsOfC).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME);
+  }
+
+  @Test
+  public void testOneNormalReferenceToken() {
+    Root root = relationSetup();
+    root.getC().setRawReference(root.getA());
+
+    List<DumpNode> nodes = TestUtils.dumpModel(root);
+    assertEquals(4, nodes.size());
+    DumpNode actualC = TestUtils.findByName(nodes, C_NAME);
+    List<DumpNode> references = referenceTokens(actualC);
+    assertThat(references).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME);
+  }
+
+}

testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java

+package de.tudresden.inf.st.jastadd.testDumper;
+
+import de.tudresden.inf.st.jastadd.dumpAst.ast.*;
+import org.assertj.core.api.Assertions;
+import org.jastadd.testDumper.ast.A;
+import org.jastadd.testDumper.ast.B;
+import org.jastadd.testDumper.ast.C;
+import org.jastadd.testDumper.ast.Root;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class TestUtils {
+  static class ExposingDumpBuilder extends DumpBuilder {
+
+    protected ExposingDumpBuilder(Object target) {
+      super(target);
+    }
+
+    @Override
+    public DumpAst build() {
+      return super.build();
+    }
+  }
+
+  public static final Random rand = new Random();
+  public static final String A_NAME = "A" + Integer.toHexString(rand.nextInt(0xFFFFFF));
+  public static final String B_NAME = "B" + Integer.toHexString(rand.nextInt(0xFFFFFF));
+  public static final String C_NAME = "C" + Integer.toHexString(rand.nextInt(0xFFFFFF));
+  public static final String ROOT_NAME = "root";
+
+  public static final Function<DumpNode, String> NAME_EXTRACTOR = dp -> {
+//    List<String> result = new ArrayList<>();
+    for (DumpToken dumpToken : dp.getDumpTokenList()) {
+      if (dumpToken.getName().equals("Name")) {
+        return dumpToken.asDumpValueToken().getValue().toString();
+      }
+    }
+//    return result;
+    return null;
+  };
+
+  public static List<DumpNode> dumpModel(Object target) {
+    return dumpModel(target, db -> {});
+  }
+
+  public static List<DumpNode> dumpModel(Object target, Consumer<DumpBuilder> options) {
+    ExposingDumpBuilder builder = new ExposingDumpBuilder(target);
+    options.accept(builder);
+    DumpAst dumpAst = builder.build();
+    List<DumpNode> result = new ArrayList<>();
+    for (DumpNode dumpNode : dumpAst.getDumpNodeList()) {
+      if (dumpNode.isAstNode()) {
+        result.add(dumpNode);
+      }
+    }
+    return result;
+  }
+
+  public static DumpNode findByName(List<DumpNode> nodes, String name) {
+    for (DumpNode node : nodes) {
+      if (name.equals(NAME_EXTRACTOR.apply(node))) {
+        return node;
+      }
+    }
+    Assertions.fail("No node found with name " + name);
+    // DummyCode to keep intellij silent
+    return new DumpNode();
+  }
+
+  public static List<DumpNode> normalChildren(DumpNode node) {
+    List<DumpNode> result = new ArrayList<>();
+    for (DumpChildNode dumpChildNode : node.getDumpChildNodeList()) {
+      if (!dumpChildNode.isList()) {
+        // then it is a DumpNormalChildNode
+        result.add(((DumpNormalChildNode) dumpChildNode).getDumpNode());
+      }
+    }
+    return result;
+  }
+
+  public static List<DumpNode> listChildren(DumpNode node) {
+    List<DumpNode> result = new ArrayList<>();
+    for (DumpChildNode dumpChildNode : node.getDumpChildNodeList()) {
+      if (dumpChildNode.isList()) {
+        // then it is a DumpListChildNode
+        ((DumpListChildNode) dumpChildNode).getInnerDumpNodeList().forEach(inner -> result.add(inner.getDumpNode()));
+      }
+    }
+    return result;
+  }
+
+  public static List<DumpNode> normalRelationChildren(DumpNode node) {
+    List<DumpNode> result = new ArrayList<>();
+    for (DumpRelation dumpRelation : node.getDumpRelationList()) {
+      if (!dumpRelation.isList()) {
+        // then it is a DumpNormalRelation
+        result.add(((DumpNormalRelation) dumpRelation).getDumpNode());
+      }
+    }
+    return result;
+  }
+
+  public static List<DumpNode> listRelationChildren(DumpNode node) {
+    List<DumpNode> result = new ArrayList<>();
+    for (DumpRelation dumpRelation : node.getDumpRelationList()) {
+      if (dumpRelation.isList()) {
+        // then it is a DumpListRelation
+        ((DumpListRelation) dumpRelation).getInnerDumpNodeList().forEach(inner -> result.add(inner.getDumpNode()));
+      }
+    }
+    return result;
+  }
+
+  public static List<DumpNode> referenceTokens(DumpNode node) {
+    List<DumpNode> result = new ArrayList<>();
+    for (DumpToken dumpToken : node.getDumpTokenList()) {
+      if (!dumpToken.isDumpValueToken()) {
+        // then it is a DumpReferenceToken
+        result.add(((DumpReferenceToken) dumpToken).getValue());
+      }
+    }
+    return result;
+  }
+
+  public static Root relationSetup() {
+    Root root = new Root();
+    root.setName(ROOT_NAME);
+    A a = new A();
+    a.setName(A_NAME);
+    root.setA(a);
+    B b = new B();
+    b.setName(B_NAME);
+    root.addB(b);
+    C c = new C();
+    c.setName(C_NAME);
+    root.setC(c);
+    return root;
+  }
+
+}