Info cleanup

15 files changed, 358 insertions, 63 deletions

diff --git a/src/main/java/bjc/rgens/parser/elements/CaseElement.java b/src/main/java/bjc/rgens/parser/elements/CaseElement.java
index 76b4efe..9fd565d 100755
--- a/src/main/java/bjc/rgens/parser/elements/CaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/CaseElement.java
@@ -40,6 +40,9 @@ public abstract class CaseElement {
 	/** The type of this element. */
 	public boolean spacing;
 
+	/**
+	 * Create a new case element.
+	 */
 	protected CaseElement() {
 		this(true);
 	}
@@ -47,8 +50,8 @@ public abstract class CaseElement {
 	/**
 	 * Create a new case element.
 	 *
-	 * @param typ
-	 *            The type of this element.
+	 * @param spacing
+	 *                Whether or not to allow spacing.
 	 */
 	protected CaseElement(boolean spacing) {
 		this.spacing = spacing;
@@ -58,7 +61,7 @@ public abstract class CaseElement {
 	 * Generate this case element.
 	 *
 	 * @param state
-	 * 	The current state of generation.
+	 *              The current state of generation.
 	 */
 	public abstract void generate(GenerationState state);
 
@@ -66,7 +69,7 @@ public abstract class CaseElement {
 	 * Create a case element from a string.
 	 *
 	 * @param csepart
-	 *            The string to convert.
+	 *                The string to convert.
 	 *
 	 * @return A case element representing the string.
 	 */
@@ -85,27 +88,31 @@ public abstract class CaseElement {
 			String specialBody = csepart.substring(1, csepart.length() - 1);
 
 			if (specialBody.matches("\\S+:\\S=\\S+")) {
-				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=").toArray(new String[0]);
+				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=")
+						.toArray(new String[0]);
 
-				if(parts.length != 2) {
-					throw new GrammarException("Colon variables must have a name and a definition");
+				if (parts.length != 2) {
+					throw new GrammarException(
+							"Colon variables must have a name and a definition");
 				}
 
 				String varName = parts[0];
 
 				char op = varName.charAt(varName.length() - 1);
 
-				trace("Colon definition w/ op %d", (int)op);
+				trace("Colon definition w/ op %d", (int) op);
 
 				// Remove the colon, plus any tacked on operator
 				varName = varName.substring(0, varName.length() - 2);
 
 				return VariableDefCaseElement.parseVariable(varName, parts[1], op, true);
 			} else if (specialBody.matches("\\S+:=\\S+")) {
-				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=").toArray(new String[0]);
+				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=")
+						.toArray(new String[0]);
 
-				if(parts.length != 2) {
-					throw new GrammarException("Colon variables must have a name and a definition");
+				if (parts.length != 2) {
+					throw new GrammarException(
+							"Colon variables must have a name and a definition");
 				}
 
 				String varName = parts[0];
@@ -114,41 +121,49 @@ public abstract class CaseElement {
 
 				return VariableDefCaseElement.parseVariable(varName, parts[1], ' ', true);
 			} else if (specialBody.matches("\\S+=\\S+")) {
-				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=").toArray(new String[0]);
-				if(parts.length != 2) {
-					throw new GrammarException("Variables must have a name and a definition");
+				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=")
+						.toArray(new String[0]);
+				if (parts.length != 2) {
+					throw new GrammarException(
+							"Variables must have a name and a definition");
 				}
 
 				// Non-colon variables can't take an operator
-				return VariableDefCaseElement.parseVariable(parts[0], parts[1], (char)0, false);
+				return VariableDefCaseElement.parseVariable(parts[0], parts[1], (char) 0,
+						false);
 			} else if (specialBody.matches("empty")) {
 				/* Literal blank, for empty cases. */
 				return new BlankCaseElement();
 			} else {
-				throw new IllegalArgumentException(String.format("Unknown special case part '%s'", specialBody));
+				throw new IllegalArgumentException(
+						String.format("Unknown special case part '%s'", specialBody));
 			}
 		} else if (csepart.matches("\\[\\S+\\]")) {
 			String rawCase = csepart.substring(1, csepart.length() - 1);
 
 			if (rawCase.matches("\\d+\\.{2}\\d+")) {
-				int firstNum = Integer.parseInt(rawCase.substring(0, rawCase.indexOf('.')));
-				int secondNum = Integer.parseInt(rawCase.substring(rawCase.lastIndexOf('.') + 1));
+				int firstNum
+						= Integer.parseInt(rawCase.substring(0, rawCase.indexOf('.')));
+				int secondNum = Integer
+						.parseInt(rawCase.substring(rawCase.lastIndexOf('.') + 1));
 
 				return new RangeCaseElement(firstNum, secondNum);
-			} else if(rawCase.contains("||")) {
-				String[] elms = LevelSplitter.def.levelSplit(rawCase, "||").toArray(new String[0]);
+			} else if (rawCase.contains("||")) {
+				String[] elms = LevelSplitter.def.levelSplit(rawCase, "||")
+						.toArray(new String[0]);
 
 				return new InlineRuleCaseElement(elms);
-			} else if(rawCase.contains("|")) {
+			} else if (rawCase.contains("|")) {
 				throw new GrammarException("Inline rule using | found, they use || now");
 
-				// String[] elms = LevelSplitter.def.levelSplit(rawCase, "|").toArray(new String[0]);
+				// String[] elms = LevelSplitter.def.levelSplit(rawCase, "|").toArray(new
+				// String[0]);
 				// return new InlineRuleCaseElement(elms);
 			} else {
 				return new RuleCaseElement(rawCase);
 			}
-		} else if(csepart.startsWith("%") && !csepart.equals("%")) {
-			return new RuleCaseElement(csepart);	
+		} else if (csepart.startsWith("%") && !csepart.equals("%")) {
+			return new RuleCaseElement(csepart);
 		} else {
 			return new LiteralCaseElement(csepart);
 		}
diff --git a/src/main/java/bjc/rgens/parser/elements/InlineRuleCaseElement.java b/src/main/java/bjc/rgens/parser/elements/InlineRuleCaseElement.java
index 66fbb96..6f3d889 100644
--- a/src/main/java/bjc/rgens/parser/elements/InlineRuleCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/InlineRuleCaseElement.java
@@ -13,13 +13,33 @@ import bjc.utils.ioutils.LevelSplitter;
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * Case element for an inline rule.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public class InlineRuleCaseElement extends CaseElement {
+	/**
+	 * The elements for this case element.
+	 */
 	public final WeightedRandom<CaseElement> elements;
 
+	/**
+	 * Create a new inline rule case element.
+	 * 
+	 * @param parts The parts of this case element.
+	 */
 	public InlineRuleCaseElement(String... parts) {
 		this(new Tree<>(), parts);
 	}
 
+	/**
+	 * Create a new inline rule case element.
+	 * 
+	 * @param errs The place to store errors in.
+	 * @param parts The parts of this case element.
+	 */
 	public InlineRuleCaseElement(ITree<String> errs, String... parts) {
 		super(true);
 
@@ -43,6 +63,7 @@ public class InlineRuleCaseElement extends CaseElement {
 		}
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		elements.generateValue(state.rnd).generate(state);
 	}
diff --git a/src/main/java/bjc/rgens/parser/elements/LitVariableCaseElement.java b/src/main/java/bjc/rgens/parser/elements/LitVariableCaseElement.java
index c5e5c6f..170794e 100755
--- a/src/main/java/bjc/rgens/parser/elements/LitVariableCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/LitVariableCaseElement.java
@@ -2,11 +2,24 @@ package bjc.rgens.parser.elements;
 
 import bjc.rgens.parser.GenerationState;
 
+/**
+ * A case element that defines a literal variable.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public class LitVariableCaseElement extends VariableDefCaseElement {
+	/**
+	 * Create a new case element for a literal variable.
+	 * 
+	 * @param name The name for the case element.
+	 * @param def The definition for the case element.
+	 */
 	public LitVariableCaseElement(String name, String def) {
 		super(name, def);
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		state.defineVar(varName, varDef);
 	}
diff --git a/src/main/java/bjc/rgens/parser/elements/LiteralCaseElement.java b/src/main/java/bjc/rgens/parser/elements/LiteralCaseElement.java
index 2621ee6..54c6454 100644
--- a/src/main/java/bjc/rgens/parser/elements/LiteralCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/LiteralCaseElement.java
@@ -2,15 +2,29 @@ package bjc.rgens.parser.elements;
 
 import bjc.rgens.parser.GenerationState;
 
+/**
+ * Case element that appends a literal.
+ * @author Ben Culkin
+ *
+ */
 public class LiteralCaseElement extends CaseElement {
+	/**
+	 * The value for this element.
+	 */
 	public String val;
 
+	/**
+	 * Create a new case element.
+	 * 
+	 * @param val The value to append.
+	 */
 	public LiteralCaseElement(String val) {
 		super(true);
 
 		this.val = val;
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		state.appendContents(val);
 	}
diff --git a/src/main/java/bjc/rgens/parser/elements/RangeCaseElement.java b/src/main/java/bjc/rgens/parser/elements/RangeCaseElement.java
index bd73f1b..2d3a771 100755
--- a/src/main/java/bjc/rgens/parser/elements/RangeCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/RangeCaseElement.java
@@ -2,10 +2,28 @@ package bjc.rgens.parser.elements;
 
 import bjc.rgens.parser.GenerationState;
 
+/**
+ * Case element which generates a range of random numbers.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public class RangeCaseElement extends CaseElement {
+	/**
+	 * The beginning point for this range.
+	 */
 	public final int begin;
+	
+	/**
+	 * The ending point for this range.
+	 */
 	public final int end;
 
+	/**
+	 * Create a new range case element.
+	 * @param beg The beginning point for the range.
+	 * @param en The ending point for the range.
+	 */
 	public RangeCaseElement(int beg, int en) {
 		super(true);
 
@@ -13,6 +31,7 @@ public class RangeCaseElement extends CaseElement {
 		end = en;
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		int val  = state.rnd.nextInt(end - begin);
 		val     += begin;
diff --git a/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java b/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java
index 1a2cf85..7fe6603 100755
--- a/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java
@@ -8,48 +8,81 @@ import bjc.rgens.parser.RGrammar;
 import bjc.rgens.parser.Rule;
 import bjc.rgens.parser.elements.vars.VariableElement;
 
+/**
+ * Case element which references a rule.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public class RuleCaseElement extends CaseElement {
+	/**
+	 * The elements for this rule.
+	 */
 	public List<VariableElement> elements;
 
+	/**
+	 * Create a new case element to reference a rule.
+	 * 
+	 * @param vl
+	 *           The text of the reference.
+	 */
 	public RuleCaseElement(String vl) {
 		super(true);
 
 		this.elements = VariableElement.parseElementString(vl);
 	}
 
+	/**
+	 * Create a new case element to reference a rule.
+	 * 
+	 * @param vl
+	 *                 The text of the reference.
+	 * @param elements
+	 *                 The elements of the reference.
+	 */
 	public RuleCaseElement(String vl, List<VariableElement> elements) {
 		super(true);
 
 		this.elements = elements;
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		GenerationState newState = state.newBuf();
 
 		boolean inName = false;
 
-		for(VariableElement elm : elements) {
+		for (VariableElement elm : elements) {
 			elm.generate(newState);
 
-			if(inName == false) inName = elm.forbidSpaces;
+			if (inName == false)
+				inName = elm.forbidSpaces;
 		}
 
 		String body = newState.getContents();
 
-		if(inName) {
+		if (inName) {
 			doGenerate(String.format("[%s]", body), state);
 		} else {
 			state.appendContents(body);
 		}
 	}
 
+	/**
+	 * Do the generation of a rule element.
+	 * 
+	 * @param acName
+	 *               The name of the rule to generation.
+	 * @param state
+	 *               The generation state.
+	 */
 	protected void doGenerate(String acName, GenerationState state) {
 		GenerationState newState = state.newBuf();
 
 		Rule rl;
 
 		String actName = acName;
-		
+
 		if (actName.startsWith("[^")) {
 			actName = "[" + actName.substring(2);
 
@@ -58,12 +91,11 @@ public class RuleCaseElement extends CaseElement {
 			rl = state.findRule(actName, true);
 		}
 
-		if(rl != null) {
+		if (rl != null) {
 			RGrammar destGrammar = rl.belongsTo;
 			newState.swapGrammar(destGrammar);
-			/* 
-			 * Don't postprocess the string, we should only do that
-			 * once.
+			/*
+			 * Don't postprocess the string, we should only do that once.
 			 */
 			String res = destGrammar.generate(actName, newState, false);
 			newState.setContents(res);
@@ -74,17 +106,17 @@ public class RuleCaseElement extends CaseElement {
 			 * Re-get this working again.
 			 */
 			/*
-			   if (ruleSearcher != null) {
-			   Set<Match<? extends String>> results = ruleSearcher.search(actName, MAX_DISTANCE);
-
-			   String[] resArray = results.stream().map(Match::getMatch).toArray((i) -> new String[i]);
-
-			   String msg = String.format("No rule '%s' defined (perhaps you meant %s?)", actName,
-			   StringUtils.toEnglishList(resArray, false));
-
-			   throw new GrammarException(msg);
-			   }
-			   */
+			 * if (ruleSearcher != null) { Set<Match<? extends String>> results =
+			 * ruleSearcher.search(actName, MAX_DISTANCE);
+			 * 
+			 * String[] resArray = results.stream().map(Match::getMatch).toArray((i) ->
+			 * new String[i]);
+			 * 
+			 * String msg = String.format("No rule '%s' defined (perhaps you meant %s?)",
+			 * actName, StringUtils.toEnglishList(resArray, false));
+			 * 
+			 * throw new GrammarException(msg); }
+			 */
 
 			String msg = String.format("No rule '%s' defined", actName);
 			throw new GrammarException(msg);
diff --git a/src/main/java/bjc/rgens/parser/elements/RuleVariableCaseElement.java b/src/main/java/bjc/rgens/parser/elements/RuleVariableCaseElement.java
index 923b56c..5806e39 100644
--- a/src/main/java/bjc/rgens/parser/elements/RuleVariableCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/RuleVariableCaseElement.java
@@ -6,15 +6,32 @@ import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.GrammarException;
 import bjc.rgens.parser.Rule;
 
+/**
+ * Case element which creates a rule variable.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public class RuleVariableCaseElement extends VariableDefCaseElement {
+	/**
+	 * Whether or not this is an exhaustive variable.
+	 */
 	public final boolean exhaust;
 
+	/**
+	 * Create a case element which creates a rule variable.
+	 * 
+	 * @param varName The name of the variable.
+	 * @param varDef The definition of the variable.
+	 * @param exhaust Whether or not this is an exhaustive variable.
+	 */
 	public RuleVariableCaseElement(String varName, String varDef, boolean exhaust) {
 		super(varName, varDef);
 
 		this.exhaust = exhaust;
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		Rule rl = state.findRule(varDef, true);
 
diff --git a/src/main/java/bjc/rgens/parser/elements/SerialCaseElement.java b/src/main/java/bjc/rgens/parser/elements/SerialCaseElement.java
index 195ba4f..3d15e8c 100644
--- a/src/main/java/bjc/rgens/parser/elements/SerialCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/SerialCaseElement.java
@@ -2,12 +2,35 @@ package bjc.rgens.parser.elements;
 
 import bjc.rgens.parser.GenerationState;
 
+/**
+ * Case element which is generated one or more times.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public class SerialCaseElement extends CaseElement {
+	/**
+	 * The case element to repeat.
+	 */
 	public final CaseElement rep;
 
+	/**
+	 * The lower bound of times to repeat.
+	 */
 	public final int lower;
+	
+	/**
+	 * The upper bound of times to repeat.
+	 */
 	public final int upper;
 
+	/**
+	 * Create a new repeating case element.
+	 * 
+	 * @param rep The case element to repeat.
+	 * @param lower The lower bound of times to repeat.
+	 * @param upper The upper bound of times to repeat.
+	 */
 	public SerialCaseElement(CaseElement rep, int lower, int upper)  {
 		super(rep.spacing);
 
@@ -17,6 +40,7 @@ public class SerialCaseElement extends CaseElement {
 		this.upper = upper;
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		int num = state.rnd.nextInt(upper - lower) + lower;
 
diff --git a/src/main/java/bjc/rgens/parser/elements/StringCaseElement.java b/src/main/java/bjc/rgens/parser/elements/StringCaseElement.java
index 00441c0..2aa720d 100755
--- a/src/main/java/bjc/rgens/parser/elements/StringCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/StringCaseElement.java
@@ -1,11 +1,26 @@
 package bjc.rgens.parser.elements;
 
+/**
+ * Case element which writes a string.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public abstract class StringCaseElement extends CaseElement {
+	/**
+	 * String written by this element.
+	 */
 	public final String val;
-	
+
+	/**
+	 * Create a new string inserting case element.
+	 * 
+	 * @param vl
+	 *           The string to insert.
+	 */
 	protected StringCaseElement(String vl) {
 		super(true);
-		
+
 		val = vl;
 	}
 
@@ -33,7 +48,7 @@ public abstract class StringCaseElement extends CaseElement {
 			return false;
 		return true;
 	}
-	
+
 	@Override
 	public String toString() {
 		return val;
diff --git a/src/main/java/bjc/rgens/parser/elements/VariableDefCaseElement.java b/src/main/java/bjc/rgens/parser/elements/VariableDefCaseElement.java
index 37a12b6..23659c7 100755
--- a/src/main/java/bjc/rgens/parser/elements/VariableDefCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/VariableDefCaseElement.java
@@ -2,6 +2,12 @@ package bjc.rgens.parser.elements;
 
 import bjc.rgens.parser.GrammarException;
 
+/**
+ * Variable defining case element.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public abstract class VariableDefCaseElement extends CaseElement {
 	/**
 	 * The name of the variable this element defines.
@@ -13,6 +19,14 @@ public abstract class VariableDefCaseElement extends CaseElement {
 	 */
 	public final String varDef;
 
+	/**
+	 * Create a variable defining case element.
+	 * 
+	 * @param name
+	 *             The name of the variable.
+	 * @param def
+	 *             The definition of the variable.
+	 */
 	public VariableDefCaseElement(String name, String def) {
 		super(false);
 
@@ -51,16 +65,33 @@ public abstract class VariableDefCaseElement extends CaseElement {
 		return true;
 	}
 
-	public static CaseElement parseVariable(String varName, String varDef, char op, boolean colon) {
-		if(varName.startsWith("$")) {
+	/**
+	 * Parse a variable reference.
+	 * 
+	 * @param varName
+	 *                The variable name.
+	 * @param varDef
+	 *                The variable definition.
+	 * @param op
+	 *                Unused as of yet.
+	 * @param colon
+	 *                Whether the colon was present in the declaration.
+	 * 
+	 * @return A case element which declares the variable.
+	 */
+	public static CaseElement parseVariable(String varName, String varDef, char op,
+			boolean colon) {
+		if (varName.startsWith("$")) {
 			// Handle normal/expanding variable definitions
-			if(colon) return new ExpVariableCaseElement(varName.substring(1), varDef);
+			if (colon)
+				return new ExpVariableCaseElement(varName.substring(1), varDef);
 
 			return new LitVariableCaseElement(varName.substring(1), varDef);
-		} else if(varName.startsWith("@")) {
+		} else if (varName.startsWith("@")) {
 			return new RuleVariableCaseElement(varName.substring(1), varDef, colon);
 		} else {
-			throw new GrammarException("Unrecognized declaration sigil " + varName.charAt(0));
+			throw new GrammarException(
+					"Unrecognized declaration sigil " + varName.charAt(0));
 		}
 	}
 }
diff --git a/src/main/java/bjc/rgens/parser/elements/vars/LiteralVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/LiteralVariableElement.java
index e7415f5..595397b 100644
--- a/src/main/java/bjc/rgens/parser/elements/vars/LiteralVariableElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/vars/LiteralVariableElement.java
@@ -2,15 +2,31 @@ package bjc.rgens.parser.elements.vars;
 
 import bjc.rgens.parser.GenerationState;
 
+/**
+ * Case element which references a literal variable.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public class LiteralVariableElement extends VariableElement {
+	/**
+	 * The name for the variable.
+	 */
 	public String val;
 
+	/**
+	 * Create a case element which references a literal variable.
+	 * 
+	 * @param forbidSpaces Whether to forbid spaces in the result.
+	 * @param val The name of the literal variable.
+	 */
 	public LiteralVariableElement(boolean forbidSpaces, String val) {
 		super(forbidSpaces);
 
 		this.val = val;
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		state.appendContents(val);
 	}
diff --git a/src/main/java/bjc/rgens/parser/elements/vars/RRefVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/RRefVariableElement.java
index e81e9f8..4001b93 100644
--- a/src/main/java/bjc/rgens/parser/elements/vars/RRefVariableElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/vars/RRefVariableElement.java
@@ -4,15 +4,30 @@ import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.GrammarException;
 import bjc.rgens.parser.Rule;
 
+/**
+ * Rule reference variable element.
+ * @author Ben Culkin
+ *
+ */
 public class RRefVariableElement extends VariableElement {
+	/**
+	 * The name of the rule to reference.
+	 */
 	public String value;
 
+	/**
+	 * Create a new rule-reference variable element.
+	 * 
+	 * @param forbidSpaces Whether to forbid spaces or not.
+	 * @param val The rule to reference.
+	 */
 	public RRefVariableElement(boolean forbidSpaces, String val) {
 		super(forbidSpaces);
 
 		value = val;
 	}
 	
+	@Override
 	public void generate(GenerationState state) {
 		Rule rl = state.findRule(value, true);
 
diff --git a/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java
index c753dfe..efd9007 100644
--- a/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java
@@ -7,6 +7,7 @@ import bjc.rgens.parser.GenerationState;
  *
  * finish when template vars are implemented.
  */
+@SuppressWarnings("javadoc")
 public class TRefVariableElement extends VariableElement {
 	public String value;
 
@@ -16,6 +17,7 @@ public class TRefVariableElement extends VariableElement {
 		value = val;
 	}
 	
+	@Override
 	public void generate(GenerationState state) {
 		/*
 		if(!state.rlVars.containsKey(val)) {
diff --git a/src/main/java/bjc/rgens/parser/elements/vars/VRefVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/VRefVariableElement.java
index e65d876..cdead80 100644
--- a/src/main/java/bjc/rgens/parser/elements/vars/VRefVariableElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/vars/VRefVariableElement.java
@@ -3,15 +3,30 @@ package bjc.rgens.parser.elements.vars;
 import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.GrammarException;
 
+/**
+ * Variable reference variable element.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public class VRefVariableElement extends VariableElement {
+	/**
+	 * The name of the variable to element.
+	 */
 	public final String nam;
 
+	/**
+	 * Create a new variable referencing variable element.
+	 * @param forbidSpaces Whether or not to forbid spaces in the element.
+	 * @param nam The name of the variable.
+	 */
 	public VRefVariableElement(boolean forbidSpaces, String nam) {
 		super(forbidSpaces);
 
 		this.nam = nam;
 	}
 
+	@Override
 	public void generate(GenerationState state) {
 		String strang = state.findVar(nam);
 
diff --git a/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java
index eb36af8..c73e249 100644
--- a/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java
@@ -7,30 +7,73 @@ import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.GrammarException;
 import bjc.utils.ioutils.LevelSplitter;
 
+/**
+ * Case element which references a variable.
+ * 
+ * @author Ben Culkin
+ *
+ */
 public abstract class VariableElement {
+	/**
+	 * Whether or not to forbid spaces in this element.
+	 */
 	public boolean forbidSpaces;
 
+	/**
+	 * Create a new variable element.
+	 * 
+	 * @param forbidSpacing
+	 *                      Whether spacing should be forbidden in this element.
+	 */
 	protected VariableElement(boolean forbidSpacing) {
 		forbidSpaces = forbidSpacing;
 	}
 
+	/**
+	 * Generate this element.
+	 * 
+	 * @param state
+	 *              The state of generation.
+	 */
 	public abstract void generate(GenerationState state);
 
+	/**
+	 * Parse a variable element from a string.
+	 * 
+	 * @param varElm
+	 *               The string to parse.
+	 * 
+	 * @return The variable elements which make up the string.
+	 */
 	public static List<VariableElement> parseElementString(String varElm) {
 		boolean forbidSpaces = LevelSplitter.def.levelContains(varElm, "-", "+");
 
 		String[] parts;
 
-		if(forbidSpaces) {
-			parts = LevelSplitter.def.levelSplit(varElm, true, "-", "+").toArray(new String[0]);
+		if (forbidSpaces) {
+			parts = LevelSplitter.def.levelSplit(varElm, true, "-", "+")
+					.toArray(new String[0]);
 		} else {
-			parts = new String[] { varElm };
+			parts = new String[] {
+					varElm
+			};
 		}
 
 		return parseElementString(forbidSpaces, parts);
 	}
 
-	public static List<VariableElement> parseElementString(boolean forbidSpaces, String... parts) {
+	/**
+	 * Parse a string of variable elements.
+	 * 
+	 * @param forbidSpaces
+	 *                     Whether or not to forbid spacing in this variable.
+	 * @param parts
+	 *                     The parts to parse into variable elements.
+	 * 
+	 * @return The variable elements from the string.
+	 */
+	public static List<VariableElement> parseElementString(boolean forbidSpaces,
+			String... parts) {
 		List<VariableElement> elms = new ArrayList<>(parts.length);
 
 		VariableElement prevElement = null;
@@ -44,23 +87,26 @@ public abstract class VariableElement {
 
 			VariableElement elm = null;
 
-			if(part.startsWith("$")) {
+			if (part.startsWith("$")) {
 				elm = new VRefVariableElement(forbidSpaces, part.substring(1));
 			} else if (part.startsWith("@")) {
-				if(forbidSpaces)
-					throw new GrammarException("Arrays references aren't allowed in rule names");
+				if (forbidSpaces)
+					throw new GrammarException(
+							"Arrays references aren't allowed in rule names");
 
 				elm = new ARefVariableElement(part.substring(1));
 			} else if (part.startsWith("%")) {
-				elm = new RRefVariableElement(forbidSpaces, String.format("[%s]", part.substring(1)));
+				elm = new RRefVariableElement(forbidSpaces,
+						String.format("[%s]", part.substring(1)));
 			} else if (part.startsWith("/")) {
 				throw new GrammarException("Template variables aren't implemented yet");
 			} else {
-				if(prevElement != null && prevElement instanceof LiteralVariableElement) {
+				if (prevElement != null
+						&& prevElement instanceof LiteralVariableElement) {
 					/* Aggregate chain literals together */
-					((LiteralVariableElement)prevElement).val += part;
+					((LiteralVariableElement) prevElement).val += part;
 				} else {
-					if(part.contains(" ")) {
+					if (part.contains(" ")) {
 						elm = new LiteralVariableElement(false, part);
 					} else {
 						elm = new LiteralVariableElement(true, part);
@@ -68,7 +114,7 @@ public abstract class VariableElement {
 				}
 			}
 
-			if(elm != null) {
+			if (elm != null) {
 				elms.add(elm);
 
 				prevElement = elm;