AST datastructure with Simple Parser for Text File Lines and JSON import/export

de.variantsync.core/src/main/java/de/variantsync/core/ast/AST.java

@@ -9,34 +9,34 @@
 import de.variantsync.core.interfaces.Grammar;
 
 /**
- * This class represents the Abstract Syntax Tree data structure.
+ * This class represents the Abstract Syntax Tree data structure. This also tests the LineGrammar indirectly.
  *
  * @param <G> a generic which needs to extend the Grammar class, defining the type of the AST
- * @param <Value> a generic which defines the value of the actual AST
+ * @param <V> a generic which defines the value of the actual AST
  * @author eric
  */
-public class AST<G extends Grammar, Value> {
+public class AST<G extends Grammar, V> {
 
 	private UUID id;
-	private Value value;
 	private G type;
-	private List<AST<G, Value>> subtrees;
+	private V value;
+	private List<AST<G, V>> subtrees;
 
 	// all attributes which should not be visible to the GSON parser need to be at least transient
 	public static transient final String INDENT_STRING = "    ";
 	public static transient final String NEXT_SEPARATOR = "\u2502 ";
 	public static transient final String NEXT_ACT_SEPARATOR = "\u251C\u2500 ";
 	public static transient final String LAST_SEPARATOR = "\u2514\u2500 ";
 
-	public AST(G type, Value value, UUID id) {
+	public AST(UUID id, G type, V value) {
 		this.id = id;
 		this.type = type;
 		this.value = value;
 		this.subtrees = new ArrayList<>();
 	}
 
-	public AST(G type, Value value) {
-		this(type, value, UUID.randomUUID());
+	public AST(G type, V value) {
+		this(UUID.randomUUID(), type, value);
 	}
 
 	/**
@@ -50,7 +50,7 @@ public UUID getId() {
 		return id;
 	}
 
-	public Value getValue() {
+	public V getValue() {
 		return value;
 	}
 
@@ -61,7 +61,7 @@ public G getType() {
 	/**
 	 * @return the subtrees as an unmodifiable List
 	 */
-	public List<AST<G, Value>> getSubtrees() {
+	public List<AST<G, V>> getSubtrees() {
 		return Collections.unmodifiableList(subtrees);
 	}
 
@@ -71,54 +71,69 @@ public int getMaxDepth() {
 		}
 
 		int maxDepth = 0;
-		for (final AST<G, Value> node : subtrees) {
+		for (final AST<G, V> node : subtrees) {
 			maxDepth = Math.max(node.getMaxDepth(), maxDepth);
 		}
 		return ++maxDepth;
 	}
 
 	/**
-	 * At the moment it is not allowed to add null as an AST.
+	 * This method calls the addChild method for each element of the given list. ASTs which would be rejected by the addChild method are skipped.
 	 *
 	 * @param toAdd List of AST which should be added as subtrees
 	 * @return true if all items where successfully added
 	 */
-	public boolean addChildren(List<AST<G, Value>> toAdd) {
+	public boolean addChildren(List<AST<G, V>> toAdd) {
+		boolean out = true;
 		if (toAdd != null) {
-			return subtrees.addAll(toAdd);
+			for (final AST<G, V> elem : toAdd) {
+				if (!addChild(elem)) {
+					out = false;
+				}
+			}
 		}
-		return false;
+		return out;
 	}
 
 	/**
-	 * At the moment it is not allowed to add null as an AST.
+	 * This method adds an element to the AST by checking its validity through the the Grammar G and assuring that the element is not null.
 	 *
 	 * @param toAdd Single AST which should be added as subtree
 	 * @return true if the item was successfully added
 	 */
-	public boolean addChild(AST<G, Value> toAdd) {
-		if (toAdd != null) {
+	public boolean addChild(AST<G, V> toAdd) {
+		if ((toAdd != null) && type.isValidChild(toAdd.type)) {
 			return subtrees.add(toAdd);
 		}
 		return false;
 	}
 
 	public int size() {
 		int tmpSize = 1;
-		for (final AST<G, Value> act : subtrees) {
+		for (final AST<G, V> act : subtrees) {
 			tmpSize += act.size();
 		}
 		return tmpSize;
 	}
 
 	/**
-	 * This recursive method prints for each tree element the Grammar type, the Value and (for the sake of readability) only the most significant bits of the
-	 * UUID. It returns the AST as human readable tree.
+	 * This method returns only the most significant bits of the UUID, the type, value and subtree size as a String of the actual AST.
 	 *
-	 * @return AST as readable String
+	 * @return UUID, Type, Value, subtree size as String
 	 */
 	@Override
 	public String toString() {
+		return String.format("[ Id: %d, Type: %s, Value: %s, Subtree-size: %d ]", id.getMostSignificantBits(), type.toString(), value.toString(),
+				subtrees.size());
+	}
+
+	/**
+	 * This recursive method prints for each tree element the Grammar type, the Value and (for the sake of readability) only the most significant bits of the
+	 * UUID. It returns the whole AST as human readable tree.
+	 *
+	 * @return AST as readable String
+	 */
+	public String printTree() {
 		final StringBuilder result = new StringBuilder();
 		if (value == null) {
 			return result.toString();
@@ -127,12 +142,12 @@ public String toString() {
 
 			final HashSet<Integer> levelFinished = new HashSet<>(); // determines if all subtrees of the actual tree on this depth have been drawn or not
 			final boolean isActualElementLastElement = false;
-			toString(result, this, depth, levelFinished, isActualElementLastElement);
+			printTree(result, this, depth, levelFinished, isActualElementLastElement);
 		}
 		return result.toString();
 	}
 
-	private void toString(StringBuilder result, AST<G, Value> parent, int depth, HashSet<Integer> levelFinished, boolean isLast) {
+	private void printTree(StringBuilder result, AST<G, V> parent, int depth, HashSet<Integer> levelFinished, boolean isLast) {
 		// print enough INDENT_STRINGS and choose separator according to whether or not there are subtrees left
 		for (int i = 0; i < depth; i++) {
 			StringBuilder line = new StringBuilder(INDENT_STRING).append(NEXT_SEPARATOR);
@@ -152,7 +167,7 @@ private void toString(StringBuilder result, AST<G, Value> parent, int depth, Has
 		}
 		result.append(String.format("%s %s uuid: %d%n", parent.type, parent.value, parent.getId().getMostSignificantBits()));
 		depth++;
-		for (final AST<G, Value> child : parent.subtrees) {
+		for (final AST<G, V> child : parent.subtrees) {
 			isLast = false;
 			if (parent.subtrees.indexOf(child) == (parent.subtrees.size() - 1)) {
 				// reached last child of parent
@@ -162,7 +177,7 @@ private void toString(StringBuilder result, AST<G, Value> parent, int depth, Has
 				// first child of new sub tree with unfinished depth so it needs NEXT_SEPARATOR later
 				levelFinished.remove(depth - 1);
 			}
-			toString(result, child, depth, levelFinished, isLast);
+			printTree(result, child, depth, levelFinished, isLast);
 		}
 	}
 }

de.variantsync.core/src/test/java/de/variantsync/core/ASTTest.java

@@ -1,9 +1,11 @@
 package de.variantsync.core;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
+import java.util.List;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -24,6 +26,7 @@ public class ASTTest {
 	AST<LineGrammar, String> mainJava;
 	int lineIndex = 0; // only for toString testing
 	final int INITIAL_AST_SIZE = 11;
+	final int INITIAL_TOSTRING_ROWS = 10;
 
 	@Before
 	public void setup() {
@@ -45,13 +48,59 @@ public void setup() {
 						new AST<>(LineGrammar.Line, "}")));
 	}
 
+	@Test
+	public void toStringOnInitialTest() {
+		final String[] lines = root.toString().split(" ");
+		assertEquals(INITIAL_TOSTRING_ROWS, lines.length);
+		// this loop skips the names of the variable and only checks their value
+		for (int i = 2; i < lines.length; i = i + 2) {
+			if (lines[i].charAt(lines[i].length() - 1) == ',') {
+				lines[i] = lines[i].substring(0, lines[i].length() - 1);
+			}
+			switch (i) {
+			case 2:
+				assertEquals(root.getId().getMostSignificantBits(), Long.parseLong(lines[i]));
+				break;
+			case 4:
+				assertEquals(root.getType().toString(), lines[i]);
+				break;
+			case 6:
+				assertEquals(root.getValue().toString(), lines[i]);
+				break;
+			case 8:
+				assertEquals(root.getSubtrees().size(), Integer.parseInt(lines[i]));
+				break;
+			default:
+				throw new IllegalArgumentException(String.format("toStringOnInitialTest has incorrect lines size: %d", i));
+			}
+		}
+	}
+
 	@Test
 	public void addOnInitialTest() {
-		final AST<LineGrammar, String> newTree = new AST<>(LineGrammar.Directory, "newROOT");
-		final int oldSize = root.getSubtrees().size();
-		root.addChild(newTree);
+		AST<LineGrammar, String> newTree = new AST<>(LineGrammar.Directory, "newROOT");
+		int oldSize = root.getSubtrees().size();
+		assertTrue(root.addChild(newTree));
 		assertEquals(oldSize + 1, root.getSubtrees().size());
 
+		newTree = new AST<>(LineGrammar.Line, "!LineYouAreLookingFor");
+		oldSize = root.getSubtrees().size();
+		assertFalse(root.addChild(newTree));
+		assertEquals(oldSize, root.getSubtrees().size());
+	}
+
+	@Test
+	public void addAllOnInitialTest() {
+		List<AST<LineGrammar, String>> newTrees = Arrays.asList(new AST<>(LineGrammar.Line, "public class Main {"), new AST<>(LineGrammar.BinaryFile, "101010"),
+				new AST<>(LineGrammar.TextFile, "fancyFile.txt"), new AST<>(LineGrammar.Directory, "fancyFolder"));
+		int oldSize = root.getSubtrees().size();
+		assertFalse(root.addChildren(newTrees));
+		assertEquals(oldSize + 3, root.getSubtrees().size());
+
+		newTrees = Arrays.asList(new AST<>(LineGrammar.Directory, "public class Main {"), new AST<>(LineGrammar.BinaryFile, "101010"));
+		oldSize = root.getSubtrees().size();
+		assertTrue(root.addChildren(newTrees));
+		assertEquals(oldSize + 2, root.getSubtrees().size());
 	}
 
 	@Test(expected = UnsupportedOperationException.class)
@@ -82,8 +131,8 @@ public void getMaxDepthOnEmptyASTTest() {
 	}
 
 	@Test
-	public void toStringOnInitialTest() {
-		final String[] lines = root.toString().split(String.format("%n"));
+	public void printTreeOnInitialTest() {
+		final String[] lines = root.printTree().split(String.format("%n"));
 		assertEquals(INITIAL_AST_SIZE, lines.length);
 		// test root values
 		final String[] rootAttributes = lines[0].split(" ");

de.variantsync.core/src/test/java/de/variantsync/core/JsonParserTestASTWithLineGrammar.java → de.variantsync.core/src/test/java/de/variantsync/core/JsonParserASTWithLineGrammarTest.java

@@ -16,7 +16,7 @@
 
 //TODO. Add compare method to AST and then compare ASTs with this method.
 
-public class JsonParserTestASTWithLineGrammar {
+public class JsonParserASTWithLineGrammarTest {
 
 	AST<LineGrammar, String> exampleAst;
 	Path examplePath;