Merge & Update

18 files changed, 399 insertions, 213 deletions

diff --git a/base/src/examples/java/bjc/utils/examples/rangen/DiabloItemGen.java b/base/src/examples/java/bjc/utils/examples/gen/DiabloItemGen.java
index 784ff03..8699527 100644
--- a/base/src/examples/java/bjc/utils/examples/rangen/DiabloItemGen.java
+++ b/base/src/examples/java/bjc/utils/examples/gen/DiabloItemGen.java
@@ -1,4 +1,4 @@
-package bjc.utils.examples.rangen;
+package bjc.utils.examples.gen;
 
 import bjc.funcdata.FunctionalStringTokenizer;
 import bjc.funcdata.ListEx;
diff --git a/base/src/examples/java/bjc/utils/examples/rangen/RandomStringExamples.java b/base/src/examples/java/bjc/utils/examples/gen/RandomStringExamples.java
index 8458de7..5e71ce0 100644
--- a/base/src/examples/java/bjc/utils/examples/rangen/RandomStringExamples.java
+++ b/base/src/examples/java/bjc/utils/examples/gen/RandomStringExamples.java
@@ -1,4 +1,4 @@
-package bjc.utils.examples.rangen;
+package bjc.utils.examples.gen;
 
 import bjc.funcdata.FunctionalList;
 import bjc.funcdata.FunctionalStringTokenizer;
diff --git a/base/src/examples/java/bjc/utils/examples/gen/ZadronsPouch.java b/base/src/examples/java/bjc/utils/examples/gen/ZadronsPouch.java
new file mode 100644
index 0000000..184d127
--- /dev/null
+++ b/base/src/examples/java/bjc/utils/examples/gen/ZadronsPouch.java
@@ -0,0 +1,220 @@
+package bjc.utils.examples.gen;
+
+import bjc.funcdata.FunctionalList;
+import bjc.funcdata.FunctionalStringTokenizer;
+import bjc.funcdata.ListEx;
+import bjc.utils.gen.RandomGrammar;
+
+/**
+ * Example showing code manipulate of random grammars
+ *
+ * @author ben
+ */
+public class ZadronsPouch {
+	/**
+	 * Main method for running application
+	 *
+	 * @param args
+	 * 	Unused CLI args
+	 */
+	public static void main(String[] args) {
+		ZadronsPouch zp = new ZadronsPouch();
+
+		for (int i = 0; i < 100; i++) {
+			ListEx<String> ls = zp.grammar.generateListValues("[item]", " ");
+
+			StringBuilder sb = new StringBuilder();
+
+			ls.forEach(sp -> sb.append(sp));
+
+			System.out.println(sb.toString().replaceAll("\\s+", " "));
+		}
+	}
+
+	private RandomGrammar<String> grammar;
+
+	/** Create a new instance with a grammar */
+	public ZadronsPouch() {
+		grammar = new RandomGrammar<>();
+
+		/*
+		 * @NOTE
+		 * 	Should there be some sort of builder sort of interface?
+		 */
+		addRule("[item]",
+		        "[egg]",      "[glove]", "[crys-sphere]", "[rock]",
+		        "[figurine]", "[vial]",  "[mini-weapon]", "[bag]",
+		        "[card]",     "[rope]",  "[box]",         "[wand]");
+
+		addEggRules();
+		addGloveRules();
+		addCrysSphereRules();
+		addRockRules();
+
+		addFigurineRules();
+		addVialRules();
+		addMiniWeaponRules();
+		addBagRules();
+
+		addCardRules();
+		addRopeRules();
+		addBoxRules();
+		addWandRules();
+	}
+
+	private void addBagRules() {
+		addRule("[bag]",
+		        "bag of [bag-type]", "[sack-type] sack", "[purse-type] purse");
+		addRule("[bag-type]",
+		        "holding",   "tricks",     "useful items",
+		        "devouring", "dwarf-kind", "invisible cloth",
+		        "monster summoning");
+		addRule("[sack-type]",
+		        "lunch", "recursive");
+		addRule("[purse-type]",
+		        "everfull");
+	}
+
+	private void addBoxRules() {
+		addRule("[box]",
+		        "[box-type] box", "cube of [box-type]");
+		addRule("[box-type]",
+		        "limited-force",    "frost-resisting", "morphing",
+		        "self-destructing", "pandora",         "panicking");
+	}
+
+	private void addCardRules() {
+		addRule("[card]",
+		        "card of [card-type]", "[card-type] card");
+		addRule("[card-type]",
+		        "fate",        "teleporting", "elusive treasure", "spell-storing",
+		        "many-things", "imprisoning", "messaging",        "bounty");
+	}
+
+	private void addCrysSphereRules() {
+		addRule("[crys-sphere]",
+		        "[sphere-type] spheres",     "[sphere-type] sphere",
+		        "lens of [lens-type]",       "[crystal-type] crystal",
+		        "crystal of [crystal-type]", "crystal ball",
+		        "crystal ball of [crys-suffix]");
+		addRule("[sphere-type]",
+		        "microphonic", "seeing-eye");
+		addRule("[lens-type]",
+		        "detection");
+		addRule("[crystal-type]",
+		        "prison", "radar");
+		addRule("[crys-suffix]",
+		        "jumping");
+	}
+
+	private void addEggRules() {
+		addRule("[egg]",
+		        "[egg-type] egg");
+		addRule("[egg-type]",
+		        "copper", "stone",      "golden",
+		        "white",  "white/pink", "glass");
+	}
+
+	private void addFigurineRules() {
+		addRule("[figurine]",
+		        "[fig-material] [fig-animal]");
+		addRule("[fig-material]",
+		        "golden", "onyx",   "serpentine", "ivory",
+		        "marble", "bronze", "jade",       "limestone");
+		addRule("[fig-animal]",
+		        "lion",     "dog",     "owl",    "goat",
+		        "elephant", "warrior", "palace", "leprechaun");
+	}
+
+	private void addGloveRules() {
+		addRule("[glove]",
+		        "gauntlets of [gauntlet-type]",
+		        "gloves of [glove-type]",
+		        "[glove-type] gloves");
+		addRule("[gauntlet-type]",
+		        "dexterity", "power");
+		addRule("[glove-type]",
+		        "pushing", "choking", "bigby", "stunning");
+	}
+
+	private void addMiniWeaponRules() {
+		addRule("[mini-weapon]",
+		        "minature [weapon-type]", "small [weapon-type]",
+		        "tiny [weapon-type]",     "[sling-type] sling",
+		        "[weapon-type]");
+		addRule("[weapon-type]",
+		        "boomerang", "arrow",  "net",
+		        "catapult",  "hammer", "sword", "club");
+		addRule("[sling-type]",
+		        "seeking");
+	}
+
+	private void addRockRules() {
+		addRule("[rock]",
+		        "[pebble-type] pebble", "stone of [stone-type]",
+		        "[stone-type] stone",   "brick of [brick-type]",
+		        "[geode-type] geode");
+		addRule("[pebble-type]",
+		        "inscribed", "elemental control");
+		addRule("[stone-type]",
+		        "good-luck",     "weight",
+		        "blind-defense", "metal-clinging");
+		addRule("[brick-type]",
+		        "flying");
+		addRule("[geode-type]",
+		        "ioun");
+	}
+
+	private void addRopeRules() {
+		addRule("[rope]",
+		        "[rope-type] rope", "rope of [rope-type]",
+		        "ball of [string-type] [string-kind]");
+		addRule("[rope-type]",
+		        "trick",    "entangling", "climbing",   "dancing",
+		        "tripping", "snaring",    "levitating", "self-entangling");
+		addRule("[string-type]",
+		        "endless");
+		addRule("[string-kind]",
+		        "string", "yarn");
+	}
+
+	private void addRule(String rule, String... cases) {
+		ListEx<ListEx<String>> cses = new FunctionalList<>();
+
+		for (String strang : cases) {
+			cses.add(FunctionalStringTokenizer.fromString(strang).toList(s -> s));
+		}
+
+		grammar.makeRule(rule, cses);
+	}
+
+	private void addVialRules() {
+		addRule("[vial]",
+		        "vial of [vial-type]",  "[vial-type] vial",
+		        "[bottle-type] bottle", "[flask-type] flask");
+		addRule("[vial-type]",
+		        "holding",    "trapping",
+		        "experience", "unnatural regeneration");
+		addRule("[bottle-type]",
+		        "ever-smoking", "wheezing",
+		        "blank potion");
+		addRule("[flask-type]",
+		        "iron");
+	}
+
+	private void addWandRules() {
+		addRule("[wand]",
+		        "[wand-type] wand", "wand of [wand-type]",
+		        "canceling [wand-type] wand");
+		addRule("[wand-type]",
+		        "magic missile", "[spell-1]",      "[spell-2]",
+		        "gusting",       "life-detecting", "zadron");
+		addRule("[spell-1]",
+		        "frost",        "fire",         "lightning",   "fear",
+		        "illumination", "polymorphing", "conjuration", "paralyzing");
+		addRule("[spell-2]",
+		        "[spell2-type] detecting");
+		addRule("[spell2-type]",
+		        "magic", "enemy", "secret door/trap");
+	}
+}
diff --git a/base/src/main/java/bjc/utils/funcutils/LambdaLock.java b/base/src/main/java/bjc/utils/funcutils/LambdaLock.java
index 46de182..c974c8c 100644
--- a/base/src/main/java/bjc/utils/funcutils/LambdaLock.java
+++ b/base/src/main/java/bjc/utils/funcutils/LambdaLock.java
@@ -30,8 +30,8 @@ public class LambdaLock {
 
 	/** Execute an action with the read lock taken.
 	 *
-	 * @param <T> The type of the result.
-	 *
+	 * @param <T> The type returned by the action.
+	 * 
 	 * @param supp The action to call.
 	 *
 	 * @return The result of the action. */
@@ -45,10 +45,11 @@ public class LambdaLock {
 		}
 	}
 
-	/** Execute an action with the write lock taken.
-	 *
-	 * @param <T> The type of the result.
-	 *
+	/**
+	 * Execute an action with the write lock taken.
+	 * 
+	 * @param <T> The type returned by the action.
+     * 
 	 * @param supp The action to call.
 	 *
 	 * @return The result of the action. */
diff --git a/base/src/main/java/bjc/utils/funcutils/ListUtils.java b/base/src/main/java/bjc/utils/funcutils/ListUtils.java
index 8631102..47141c2 100644
--- a/base/src/main/java/bjc/utils/funcutils/ListUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/ListUtils.java
@@ -1,9 +1,6 @@
 package bjc.utils.funcutils;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.*;
 import java.util.function.*;
 
 import bjc.funcdata.FunctionalList;
@@ -291,19 +288,8 @@ public class ListUtils {
 			T elm1 = list.get(0);
 			T elm2 = list.get(1);
 
-			List<T> currPerm = new ArrayList<>(2);
-
-			currPerm.add(elm1);
-			currPerm.add(elm2);
-
-			permutes.add(currPerm);
-
-			currPerm = new ArrayList<>(2);
-
-			currPerm.add(elm2);
-			currPerm.add(elm1);
-
-			permutes.add(currPerm);
+			permutes.add(Arrays.asList(elm1, elm2));
+			permutes.add(Arrays.asList(elm2, elm1));
 
 			return permutes;
 		}
diff --git a/base/src/main/java/bjc/utils/funcutils/StringUtils.java b/base/src/main/java/bjc/utils/funcutils/StringUtils.java
index b029e1d..0b57e18 100644
--- a/base/src/main/java/bjc/utils/funcutils/StringUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/StringUtils.java
@@ -8,21 +8,15 @@ import com.ibm.icu.text.BreakIterator;
 
 import bjc.utils.ioutils.LevelSplitter;
 
-/**
- * Utility methods for operations on strings.
+/** Utility methods for operations on strings.
  *
- * @author ben
- */
+ * @author ben */
 public class StringUtils {
-	/**
-	 * Check if a string consists only of one or more matches of a regular
+	/**Check if a string consists only of one or more matches of a regular
 	 * expression.
 	 *
-	 * @param input
-	 *               The string to check.
-	 *
-	 * @param rRegex
-	 *               The regex to see if the string only contains matches of.
+	 * @param input The string to check.
+	 * @param rRegex The regex to see if the string only contains matches of.
 	 *
 	 * @return Whether or not the string consists only of multiple matches of the
 	 *         provided regex.
@@ -31,38 +25,29 @@ public class StringUtils {
 		if (input == null)       throw new NullPointerException("Input must not be null");
 		else if (rRegex == null) throw new NullPointerException("Regex must not be null");
 
-		/*
-		 * This regular expression is fairly simple.
+		/* This regular expression is fairly simple.
 		 *
 		 * First, we match the beginning of the string. Then, we start a non-capturing
 		 * group whose contents are the passed in regex. That group is then matched one
-		 * or more times and the pattern matches to the end of the string.
-		 */
+		 * or more times and the pattern matches to the end of the string. */
 		return input.matches("\\A(?:" + rRegex + ")+\\Z");
 	}
 
-	/**
-	 * Indent the string being built in a StringBuilder n levels.
-	 *
-	 * @param builder
-	 *                The builder to indent in.
+	/** Indent the string being built in a StringBuilder n levels.
 	 *
-	 * @param levels
-	 *                The number of levels to indent.
+	 * @param builder The builder to indent in.
+	 * @param levels The number of levels to indent.
 	 */
 	public static void indentNLevels(final StringBuilder builder, final int levels) {
 		for (int i = 0; i < levels; i++) builder.append("\t");
 	}
 
-	/**
-	 * Print out a deque with a special case for easily showing a deque is empty.
-	 *
-	 * @param <ContainedType>
-	 *                        The type in the deque.
+	/** Print out a deque with a special case for easily showing a deque is empty.
 	 *
-	 * @param queue
-	 *                        The deque to print.
+	 * @param <ContainedType> The type in the deque.
 	 *
+	 * @param queue The deque to print.
+	 * 
 	 * @return A string version of the deque, with allowance for an empty deque.
 	 */
 	public static <ContainedType> String printDeque(final Deque<ContainedType> queue) {
@@ -72,15 +57,10 @@ public class StringUtils {
 	/**
 	 * Converts a sequence to an English list.
 	 *
-	 * @param objects
-	 *                The sequence to convert to an English list.
-	 *
+	 * @param objects The sequence to convert to an English list.
 	 * @param join
-	 *                The string to use for separating the last element from the
-	 *                rest.
-	 *
-	 * @param comma
-	 *                The string to use as a comma
+	 *     The string to use for separating the last element from the rest.
+	 * @param comma The string to use as a comma
 	 *
 	 * @return The sequence as an English list.
 	 */
@@ -129,15 +109,11 @@ public class StringUtils {
 		return sb.toString();
 	}
 
-	/**
-	 * Converts a sequence to an English list.
-	 *
-	 * @param objects
-	 *                The sequence to convert to an English list.
+	/** Converts a sequence to an English list.
 	 *
+	 * @param objects The sequence to convert to an English list.
 	 * @param join
-	 *                The string to use for separating the last element from the
-	 *                rest.
+	 *     The string to use for separating the last element from the rest.
 	 *
 	 * @return The sequence as an English list.
 	 */
@@ -145,14 +121,10 @@ public class StringUtils {
 		return toEnglishList(objects, join, ",");
 	}
 
-	/**
-	 * Converts a sequence to an English list.
-	 *
-	 * @param objects
-	 *                The sequence to convert to an English list.
+	/** Converts a sequence to an English list.
 	 *
-	 * @param and
-	 *                Whether to use 'and' or 'or'.
+	 * @param objects The sequence to convert to an English list.
+	 * @param and Whether to use 'and' or 'or'.
 	 *
 	 * @return The sequence as an English list.
 	 */
@@ -161,11 +133,9 @@ public class StringUtils {
 		else     return toEnglishList(objects, "or");
 	}
 
-	/**
-	 * Count the number of graphemes in a string.
+	/** Count the number of graphemes in a string.
 	 *
-	 * @param value
-	 *              The string to check.
+	 * @param value The string to check.
 	 *
 	 * @return The number of graphemes in the string.
 	 */
@@ -179,14 +149,11 @@ public class StringUtils {
 		return count;
 	}
 
-	/**
-	 * Count the number of times a pattern matches in a given string.
+	/** Count the number of times a pattern matches in a given string.
 	 *
-	 * @param value
-	 *                The string to count occurances in.
-	 *
-	 * @param pattern
-	 *                The pattern to count occurances of.
+	 * @param value The string to count occurrences in.
+	 * @param pattern The pattern to count occurrences of.
+	 * 
 	 * @return The number of times the pattern matches.
 	 */
 	public static int countMatches(final String value, final String pattern) {
@@ -198,42 +165,36 @@ public class StringUtils {
 		return num;
 	}
 
-	/**
-	 * Get a substring until a specified string.
+	/** Get a substring until a specified string.
 	 *
-	 * @param strang
-	 *               The string to substring.
-	 * @param vx
-	 *               The place to substring until.
+	 * @param strang The string to substring.
+	 * @param until The place to substring until.
 	 *
 	 * @return The specified substring.
 	 */
-	public static String substringTo(String strang, String vx) {
-		return substringTo(strang, vx, true);
+	public static String substringTo(String strang, String until) {
+		return substringTo(strang, until, true);
 	}
 
 	/**
 	 * Get a substring until a specified string.
 	 *
-	 * @param strang
-	 *                  The string to substring.
-	 * @param vx
-	 *                  The place to substring until.
-	 * @param allowFail
-	 *                  Whether or not to allow failure.
+	 * @param strang The string to substring.
+	 * @param until The place to substring until.
+	 * @param allowFail Whether or not to allow failure.
 	 *
 	 * @return The specified substring, or null if the specified place to substring
 	 *         to was not found, and we were not allowed to fail.
 	 */
-	public static String substringTo(String strang, String vx, boolean allowFail) {
-		int idx = strang.indexOf(vx);
+	public static String substringTo(String strang, String until, boolean allowFail) {
+		int idx = strang.indexOf(until);
 
 		if (idx == -1) {
 			if (allowFail) return strang;
 			else           return null;
 		}
 
-		return strang.substring(0, strang.indexOf(vx));
+		return strang.substring(0, strang.indexOf(until));
 	}
 
 	private static class LineIterator implements Iterator<String> {
@@ -282,11 +243,9 @@ public class StringUtils {
 		}
 	}
 
-	/**
-	 * Read a series of lines from an input source.
+	/** Read a series of lines from an input source.
 	 *
-	 * @param scn
-	 *            The source to read the lines from.
+	 * @param scn The source to read the lines from.
 	 *
 	 * @return An iterator over the lines from the input source.
 	 */
@@ -297,17 +256,10 @@ public class StringUtils {
 	/**
 	 * Read a series of lines from an input source.
 	 *
-	 * @param scn
-	 *                        The source to read the lines from.
-	 *
-	 * @param processComments
-	 *                        Whether or not to skip comment lines.
-	 *
-	 * @param commentInd
-	 *                        Indicator for starting comment lines.
-	 *
-	 * @param skipBlanks
-	 *                        Whether or not to skip blank lines.
+	 * @param scn The source to read the lines from.
+	 * @param processComments Whether or not to skip comment lines.
+	 * @param commentInd Indicator for starting comment lines.
+	 * @param skipBlanks Whether or not to skip blank lines.
 	 *
 	 * @return An iterator over the lines from the input source.
 	 */
@@ -323,27 +275,23 @@ public class StringUtils {
 		return itr;
 	}
 
-	/**
-	 * Check if a string contains any one of a specified number of things,
+	/** Check if a string contains any one of a specified number of things,
 	 * respecting groups.
 	 *
-	 * @param haystack
-	 *                 The string to look in.
-	 * @param needles
-	 *                 The strings to look for.
+	 * @param haystack The string to look in.
+	 * @param needles The strings to look for.
+	 * 
 	 * @return Whether or not any of the strings were contained outside of groups.
 	 */
 	public static boolean levelContains(String haystack, String... needles) {
 		return LevelSplitter.def.levelContains(haystack, needles);
 	}
 
-	/**
-	 * Split a string, respecting groups.
+	/** Split a string, respecting groups.
 	 *
-	 * @param phrase
-	 *               The string to split.
-	 * @param splits
-	 *               The strings to split on.
+	 * @param phrase The string to split.
+	 * @param splits The strings to split on.
+	 * 
 	 * @return A list of split strings. If keepDelims is true, it also includes the
 	 *         delimiters in between the split strings.
 	 */
@@ -351,15 +299,12 @@ public class StringUtils {
 		return LevelSplitter.def.levelSplit(phrase, false, splits);
 	}
 
-	/**
-	 * Split a string, respecting groups.
+	/** Split a string, respecting groups.
 	 *
-	 * @param phrase
-	 *                   The string to split.
-	 * @param keepDelims
-	 *                   Whether or not to include the delimiters in the results.
-	 * @param splits
-	 *                   The strings to split on.
+	 * @param phrase The string to split.
+	 * @param keepDelims Whether or not to include the delimiters in the results.
+	 * @param splits The strings to split on.
+	 * 
 	 * @return A list of split strings. If keepDelims is true, it also includes the
 	 *         delimiters in between the split strings.
 	 */
@@ -367,4 +312,4 @@ public class StringUtils {
 			String... splits) {
 		return LevelSplitter.def.levelSplit(phrase, keepDelims, splits);
 	}
-}
+}
\ No newline at end of file
diff --git a/base/src/main/java/bjc/utils/funcutils/TestUtils.java b/base/src/main/java/bjc/utils/funcutils/TestUtils.java
index 681a8e6..860a565 100644
--- a/base/src/main/java/bjc/utils/funcutils/TestUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/TestUtils.java
@@ -36,6 +36,8 @@ public class TestUtils {
 		 * Even though it's awkward, the boolean has to come first. Otherwise, there are
 		 * cases where the compiler will get confused as to what the right value for T
 		 * is, and be unable to pick an overload.
+		 * 
+		 * This is a case where named parameter would be rather useful.
 		 */
 		assertIteratorEquals(src, vals);
 
diff --git a/base/src/main/java/bjc/utils/ioutils/LevelSplitter.java b/base/src/main/java/bjc/utils/ioutils/LevelSplitter.java
index 22cf2c5..e808bec 100644
--- a/base/src/main/java/bjc/utils/ioutils/LevelSplitter.java
+++ b/base/src/main/java/bjc/utils/ioutils/LevelSplitter.java
@@ -5,29 +5,24 @@ import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-/**
- * Splits a string on a delimiter, respecting grouping delimiters.
+/** Splits a string on a delimiter, respecting grouping delimiters.
  *
  * By default, grouping delimiters are (), [], {}, and &lt;&gt;, as well as single and
  * double quoted strings.
  *
- * @author bjculkin
- *
- */
+ * @author bjculkin */
 public class LevelSplitter {
-	/**
-	 * Defaultly configured level splitter.
-	 */
+	/** Default configured level splitter. */
 	public final static LevelSplitter def = new LevelSplitter();
 
-	/**
-	 * Check if a string contains any one of a specified number of things,
+	/** Should empty strings be ignored? */
+	public boolean ignoreEmpty = false;
+	
+	/** Check if a string contains any one of a specified number of things,
 	 * respecting groups.
 	 *
-	 * @param haystack
-	 *                 The string to look in.
-	 * @param needles
-	 *                 The strings to look for.
+	 * @param haystack The string to look in.
+	 * @param needles The strings to look for.
 	 * @return Whether or not any of the strings were contained outside of groups.
 	 */
 	public boolean levelContains(String haystack, String... needles) {
@@ -88,13 +83,11 @@ public class LevelSplitter {
 		return false;
 	}
 
-	/**
-	 * Split a string, respecting groups.
+	/** Split a string, respecting groups.
 	 *
-	 * @param phrase
-	 *               The string to split.
-	 * @param splits
-	 *               The strings to split on.
+	 * @param phrase The string to split.
+	 * @param splits The strings to split on.
+	 * 
 	 * @return A list of split strings. If keepDelims is true, it also includes the
 	 *         delimiters in between the split strings.
 	 */
@@ -102,15 +95,12 @@ public class LevelSplitter {
 		return levelSplit(phrase, false, splits);
 	}
 
-	/**
-	 * Split a string, respecting groups.
+	/** Split a string, respecting groups.
 	 *
-	 * @param phrase
-	 *                   The string to split.
-	 * @param keepDelims
-	 *                   Whether or not to include the delimiters in the results.
-	 * @param splits
-	 *                   The strings to split on.
+	 * @param phrase The string to split.
+	 * @param keepDelims Whether or not to include the delimiters in the results.
+	 * @param splits The strings to split on.
+	 * 
 	 * @return A list of split strings. If keepDelims is true, it also includes the
 	 *         delimiters in between the split strings.
 	 */
@@ -140,8 +130,7 @@ public class LevelSplitter {
 					if (work.regionMatches(i, split, 0, split.length())) {
 						strangs.add(work.substring(0, i));
 
-						if (keepDelims)
-							strangs.add(split);
+						if (keepDelims) strangs.add(split);
 
 						work = work.substring(i + split.length());
 						i = 0;
diff --git a/base/src/main/java/bjc/utils/ioutils/LineReader.java b/base/src/main/java/bjc/utils/ioutils/LineReader.java
deleted file mode 100644
index 2ac2797..0000000
--- a/base/src/main/java/bjc/utils/ioutils/LineReader.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package bjc.utils.ioutils;
-
-/**
- * A line reader
- * 
- * @author bjculkin
- *
- */
-public class LineReader implements AutoCloseable {
-	//private Scanner scn;
-
-	@Override
-	public void close() {
-		//scn.close();
-	}
-
-	// @TODO Implement me - ben, 1/6/20
-}
diff --git a/base/src/main/java/bjc/utils/ioutils/SimpleProperties.java b/base/src/main/java/bjc/utils/ioutils/SimpleProperties.java
index 754ed45..d380866 100644
--- a/base/src/main/java/bjc/utils/ioutils/SimpleProperties.java
+++ b/base/src/main/java/bjc/utils/ioutils/SimpleProperties.java
@@ -170,17 +170,20 @@ public class SimpleProperties implements Map<String, String> {
 		return props.isEmpty();
 	}
 
-	@Override
+	@SuppressWarnings("unlikely-arg-type")
+    @Override
 	public boolean containsKey(final Object key) {
 		return props.containsKey(key);
 	}
 
-	@Override
+	@SuppressWarnings("unlikely-arg-type")
+    @Override
 	public boolean containsValue(final Object value) {
 		return props.containsValue(value);
 	}
 
-	@Override
+	@SuppressWarnings("unlikely-arg-type")
+    @Override
 	public String get(final Object key) {
 		return props.get(key);
 	}
@@ -190,7 +193,8 @@ public class SimpleProperties implements Map<String, String> {
 		return props.put(key, value);
 	}
 
-	@Override
+	@SuppressWarnings("unlikely-arg-type")
+    @Override
 	public String remove(final Object key) {
 		return props.remove(key);
 	}
diff --git a/base/src/main/java/bjc/utils/ioutils/blocks/package-info.java b/base/src/main/java/bjc/utils/ioutils/blocks/package-info.java
new file mode 100644
index 0000000..3d05ed4
--- /dev/null
+++ b/base/src/main/java/bjc/utils/ioutils/blocks/package-info.java
@@ -0,0 +1,22 @@
+/** This package contains a number of classes useful for processing input that
+ * is structured as a series of 'blocks' or records.
+ * <p>
+ *
+ * The most fundamental unit here is that of {@link Block}. Each {@link
+ * BlockReader} will yield a sequence of these, which contain a piece of text
+ * as its contents, as well as the beginning/ending line for that block.
+ *
+ * There are a number of different types of {@link BlockReader}, which are
+ * summarized here.
+ * </p>
+ *
+ * <dl>
+ * 	<dt>{@link SimpleBlockReader}</dt>
+ * 	<dd>
+ * 		The most basic form of BlockReader. This uses a regular expression to
+ * 		delimit input reader from a {@link Reader} into a series of blocks.
+ * 		Listed first, because this is
+ * 	</dd>
+ * </dl>
+ * @author Ben Culkin */
+package bjc.utils.ioutils.blocks;
diff --git a/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java b/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java
index 28e9cd7..176f588 100644
--- a/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java
+++ b/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java
@@ -79,7 +79,8 @@ public class MutablePatternMatcher<ReturnType, InputType>
 	 * 
 	 * @return Whether or not the pattern was removed.
 	 */
-	public boolean removePattern(ComplexPattern<ReturnType, ?, InputType> pattern) {
+	@SuppressWarnings("unlikely-arg-type")
+    public boolean removePattern(ComplexPattern<ReturnType, ?, InputType> pattern) {
 		return patterns.remove(pattern);
 	}
 }
diff --git a/base/src/main/java/bjc/utils/patterns/SimplePatternMatcher.java b/base/src/main/java/bjc/utils/patterns/SimplePatternMatcher.java
index fea947a..9fae976 100644
--- a/base/src/main/java/bjc/utils/patterns/SimplePatternMatcher.java
+++ b/base/src/main/java/bjc/utils/patterns/SimplePatternMatcher.java
@@ -7,6 +7,7 @@ import bjc.data.*;
  * 
  * @author Ben Culkin
  * 
+ * @param <InputType> The type input to the pattern matcher.
  * @param <ReturnType> The type returned by the pattern.
  */
 public class SimplePatternMatcher<ReturnType, InputType>
diff --git a/base/src/test/java/bjc/utils/test/ioutils/LevelSplitterTest.java b/base/src/test/java/bjc/utils/test/ioutils/LevelSplitterTest.java
index 5fb3756..b0db059 100644
--- a/base/src/test/java/bjc/utils/test/ioutils/LevelSplitterTest.java
+++ b/base/src/test/java/bjc/utils/test/ioutils/LevelSplitterTest.java
@@ -3,6 +3,8 @@ package bjc.utils.test.ioutils;
 import static bjc.utils.funcutils.TestUtils.assertListEquals;
 import static bjc.utils.test.ioutils.LevelSplitterTest.RXPair.pair;
 
+import java.util.*;
+
 import org.junit.Test;
 
 import bjc.utils.ioutils.LevelSplitter;
@@ -28,21 +30,21 @@ public class LevelSplitterTest {
 		}
 	}
 
-	/**
-	 * Test regex splitter.
-	 */
+	/** Test regex splitter. */
 	@Test
 	public void testRXSplit() {
 		// LevelSplitter splitter = LevelSplitter.def;
 
 		// Check generic splitting works
-		assertRXSplit("\\s+", pair("", ""), pair("a", "a"), pair("a b", "a", "b"),
+		assertRXSplit("\\s+",
+		        pair("", ""), pair("a", "a"), pair("a b", "a", "b"),
 				pair("a  b", "a", "b"), pair("a\t \tb", "a", "b"));
 	}
 
 	private static void assertRXSplit(String pat, RXPair... pairs) {
 		for (RXPair pair : pairs) {
-			assertListEquals(LevelSplitter.def.levelSplitRX(pair.inp, pat), pair.outp);
+			List<String> res = LevelSplitter.def.levelSplitRX(pair.inp, pat);
+            assertListEquals(res, pair.outp);
 		}
 	}
 }
diff --git a/clformat/example-format-strings.sprop b/clformat/example-format-strings.sprop
new file mode 100644
index 0000000..6de136a
--- /dev/null
+++ b/clformat/example-format-strings.sprop
@@ -0,0 +1,6 @@
+# Dump hexadecimal output in some manner
+dumpHexOutput ~:{~8,'0X: ~2{~8@{~#     ~:;~2,'0X ~]~}  ~}~v@{  ~}~2{~8@{~A~} ~}~%~}
+# Print a list in proper English style (no Oxford comma)
+englishList ~#[ none~; ~A~; ~A and ~A:;~@{~#*[ ~A,~; and ~A~; ~A~]~}~]
+# An alternate variant which abbreviates long lists
+abbrevList ~#[NONE~;~a~;~a and ~a~:;~a, ~a~]~#[~; and ~a~:;, ~a, etc~]
diff --git a/clformat/src/example/java/bjc/utils/ioutils/format/examples/CLFormatCLI.java b/clformat/src/example/java/bjc/utils/ioutils/format/examples/CLFormatCLI.java
new file mode 100644
index 0000000..71e6b92
--- /dev/null
+++ b/clformat/src/example/java/bjc/utils/ioutils/format/examples/CLFormatCLI.java
@@ -0,0 +1,40 @@
+package bjc.utils.ioutils.format.examples;
+
+import java.io.*;
+import java.util.*;
+
+public class CLFormatCLI {
+	public static void main(String[] args) {
+		Scanner scn = new Scanner(System.in);
+		PrintStream output = System.out;
+
+		runCLI(scn, output);
+	}
+
+	private static void runCLI(Scanner input, PrintStream output) {
+		output.println("CLFormat CLI v0.1");
+		output.println("Enter a command (m for help)");
+
+		String inp = input.nextLine().trim();
+
+		boolean verboseErrors = false;
+
+		while (!inp.equals("q")) {
+			String[] args = inp.split("\\S+");
+
+			String command = args[0];
+			switch(command) {
+			default:
+				if (verboseErrors) {
+					output.printf("! Error: %s is not a recognizable command\n", inp);
+				} else {
+					output.println("! UC");
+				}
+			}
+
+			output.println("Enter a command (m for help)");
+
+			String inp = input.nextLine().trim();
+		}
+	}
+}
diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java
index 3dfb45b..0589992 100644
--- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java
+++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java
@@ -93,12 +93,8 @@ class AestheticEdict implements Edict {
 		int minpad = minpadPar.asInt(itemTape,
 				"minumum amount of padding", "A", 0);
 
-	//	if (padBefore) doPadding(work, padchar, mincol, colinc, minpad);
-
 		work.append(itemString);
 
-	//	if (!padBefore) doPadding(work, padchar, mincol, colinc, minpad);
-
 		String padding = createPadding(work, padchar, mincol, colinc, minpad);
 		if (padBefore) work.insert(0, padding);
 		else           work.append(padding);
@@ -126,13 +122,4 @@ class AestheticEdict implements Edict {
 
 		return padding.toString();
 	}
-
-	private void doPadding(StringBuilder work, char padchar, int mincol, int colinc,
-			int minpad) {
-		for (int i = 0; i < minpad; i++) work.append(padchar);
-
-		for (int i = work.length(); i < mincol; i++) {
-			for (int k = 0; k < colinc; k++) work.append(padchar);
-		}
-	}
 }
diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/DecimalDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/DecimalDirective.java
index 0d1d0df..6447eef 100644
--- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/DecimalDirective.java
+++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/DecimalDirective.java
@@ -48,8 +48,6 @@ public class DecimalDirective implements Directive {
 }
 
 class DecimalEdict implements Edict {
-	private static final FieldPosition ZERO_FIELD = new FieldPosition(0);
-
 	private CLValue decFormat;
 
 	public DecimalEdict(CLValue decForm) {