Merge cleanups

3 files changed, 118 insertions, 14 deletions

diff --git a/src/main/java/bjc/rgens/parser/templates/GrammarTemplate.java b/src/main/java/bjc/rgens/parser/templates/GrammarTemplate.java
index a57897c..ef0bf3a 100644
--- a/src/main/java/bjc/rgens/parser/templates/GrammarTemplate.java
+++ b/src/main/java/bjc/rgens/parser/templates/GrammarTemplate.java
@@ -1,5 +1,12 @@
 package bjc.rgens.parser.templates;
 
+import bjc.rgens.parser.ConfigSet;
+import bjc.rgens.parser.GenerationState;
+import bjc.rgens.parser.LoadOptions;
+
+import bjc.utils.data.ITree;
+import bjc.utils.data.Tree;
+
 import java.io.Reader;
 import java.util.ArrayList;
 import java.util.List;
@@ -8,19 +15,48 @@ import java.util.Scanner;
 import bjc.rgens.parser.ConfigSet;
 import bjc.rgens.parser.GenerationState;
 
+/**
+ * Represents a grammar template.
+ *
+ * @author Ben Culkin
+ */
 public class GrammarTemplate {
+	/**
+	 * The config set the template belongs to.
+	 */
 	public ConfigSet belongsTo;
 
+	/**
+	 * The name of the template.
+	 */
 	public String name;
 
+	/**
+	 * The elements in the template.
+	 */
 	public final List<TemplateElement> elements;
 
+	/**
+	 * Whether or not to do spacing of elements.
+	 */
 	public boolean doSpacing = true;
 
+	/**
+	 * Create a new grammar template.
+	 *
+	 * @param elements
+	 * 		The elements that belong to the template.
+	 */
 	public GrammarTemplate(List<TemplateElement> elements) {
 		this.elements = elements;
 	}
 
+	/**
+	 * Generate the template.
+	 *
+	 * @param state
+	 * 		The state for generating a template.
+	 */
 	public void generate(GenerationState state) {
 		for(TemplateElement element : elements) {
 			element.generate(state);
@@ -30,27 +66,43 @@ public class GrammarTemplate {
 		}
 	}
 
-	public static GrammarTemplate readTemplate(Reader rdr) {
+	/**
+	 * Read a template from an input source.
+	 *
+	 * @param rdr
+	 * 		The reader to get input from.
+	 *
+	 * @param errs
+	 * 		The errors/information to generate during loading.
+	 *
+	 * @return The generated template.
+	 */
+	public static GrammarTemplate readTemplate(Reader rdr, ITree<String> errs) {
 		List<TemplateElement> elements = new ArrayList<>();
 		GrammarTemplate template = new GrammarTemplate(elements);
 
 		Scanner scn = new Scanner(rdr);
 		scn.useDelimiter("\\R");
 
-		//int lno = 0;
+		int lno = 0;
 		while(scn.hasNextLine()) {
 			String ln = scn.nextLine();
-			//lno += 1;
+			lno += 1;
 
+			ITree<String> kid = new Tree<>(String.format("INFO: Line %d", lno));
 			switch(ln.charAt(0)) {
 			case '#':
 				// Ignore comments
 				break;
 			case '/':
-				handlePragma(elements, template, ln.substring(1));
+				handlePragma(elements, template, ln.substring(1), kid);
 				break;
 			default:
-				handleLine(elements, template, ln);
+				handleLine(elements, template, ln, kid);
+			}
+
+			if (kid.size() > 0) {
+				errs.addChild(kid);
 			}
 		}
 
@@ -59,18 +111,26 @@ public class GrammarTemplate {
 		return template;
 	}
 
-	private static void handleLine(List<TemplateElement> elements, GrammarTemplate template, String ln) {
+	private static void handleLine(List<TemplateElement> elements, GrammarTemplate template, String ln, ITree<String> errs) {
 		if(ln.matches("^.*?\\$@.+?@\\$.*$")) {
 			/*
 			 * Handle live templates
 			 */
-			elements.add(new LiveTemplateElement(ln));
+			elements.add(new LiveTemplateElement(ln, errs));
 		} else {
-			elements.add(new LiteralTemplateElement(ln));
+			elements.add(new LiteralTemplateElement(ln, errs));
 		}
 	}
 
-	private static void handlePragma(List<TemplateElement> elements, GrammarTemplate template, String ln) {
-		// TODO
+	private static void handlePragma(List<TemplateElement> elements, GrammarTemplate template, String ln, ITree<String> errs) {
+		/*
+		 * @TODO 2/8/2019 Ben Culkin :TemplatePragmas
+		 * Implement template pragmas.
+		 *
+		 * Implement template pragmas. Mainly, this means that the 'choose'
+		 * based ones need to be implemented based off of the provided sample
+		 * template.
+		 */
+		errs.addChild("ERROR: Template pragmas are not yet implemented");
 	}
 }
diff --git a/src/main/java/bjc/rgens/parser/templates/LiteralTemplateElement.java b/src/main/java/bjc/rgens/parser/templates/LiteralTemplateElement.java
index ca4b32f..2f0a571 100644
--- a/src/main/java/bjc/rgens/parser/templates/LiteralTemplateElement.java
+++ b/src/main/java/bjc/rgens/parser/templates/LiteralTemplateElement.java
@@ -1,16 +1,33 @@
 package bjc.rgens.parser.templates;
 
+import bjc.utils.data.ITree;
+
 import bjc.rgens.parser.GenerationState;
 
+/**
+ * Represents a literal text element.
+ *
+ * @author Ben Culkin
+ */
 public class LiteralTemplateElement extends TemplateElement {
+	/**
+	 * The literal value of the element.
+	 */
 	public final String val;
 
-	public LiteralTemplateElement(String val) {
+	/**
+	 * Create a new literal template element.
+	 *
+	 * @param val
+	 * 		The string to insert.
+	 */
+	public LiteralTemplateElement(String val, ITree<String> errs) {
 		super(true);
 
 		this.val = val;
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		state.appendContents(val);
 	}
diff --git a/src/main/java/bjc/rgens/parser/templates/LiveTemplateElement.java b/src/main/java/bjc/rgens/parser/templates/LiveTemplateElement.java
index 80c8315..81c0c47 100644
--- a/src/main/java/bjc/rgens/parser/templates/LiveTemplateElement.java
+++ b/src/main/java/bjc/rgens/parser/templates/LiveTemplateElement.java
@@ -6,6 +6,12 @@ import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import bjc.utils.data.BooleanToggle;
+import bjc.utils.data.ITree;
+import bjc.utils.data.Tree;
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IList;
+
 import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.RGrammarParser;
 import bjc.rgens.parser.elements.CaseElement;
@@ -13,12 +19,30 @@ import bjc.rgens.parser.elements.LiteralCaseElement;
 import bjc.utils.data.BooleanToggle;
 import bjc.utils.funcdata.FunctionalList;
 
+/**
+ * A template element that can contain rule elements.
+ *
+ * @author Ben Culkin.
+ */
 public class LiveTemplateElement extends TemplateElement {
+	// Pattern for matching elements (any number of characters bracketed by '$@' and '@$')
 	private static final Pattern INSERT_PAT = Pattern.compile("\\$@(.+?)@\\$");
 
+	/**
+	 * The sub-elements of this element.
+	 */
 	public final List<List<CaseElement>> elements;
 
-	public LiveTemplateElement(String val) {
+	/**
+	 * Create a new template element.
+	 *
+	 * @param val
+	 * 		The string to parse this element from.
+	 *
+	 * @param errs
+	 * 		A tree to add errors &amp; information to.
+	 */
+	public LiveTemplateElement(String val, ITree<String> errs) {
 		super(true);
 
 		elements = new ArrayList<>();
@@ -30,10 +54,12 @@ public class LiveTemplateElement extends TemplateElement {
 			mat.appendReplacement(sb, "");
 			String body = mat.group(1);
 
-			FunctionalList<CaseElement> elms = (FunctionalList<CaseElement>)RGrammarParser.parseElementString(body).getLeft();
+			List<CaseElement> elms = new ArrayList<>();
+
+			int weight = RGrammarParser.parseElementString(body, elms, errs);
 
 			elements.add(Arrays.asList(new LiteralCaseElement(sb.toString())));
-			elements.add(elms.getInternal());
+			elements.add(elms);
 
 			sb = new StringBuffer();
 		}
@@ -42,6 +68,7 @@ public class LiveTemplateElement extends TemplateElement {
 		elements.add(Arrays.asList(new LiteralCaseElement(sb.toString())));
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		BooleanToggle bt = new BooleanToggle(false);