Setpoint after fixing an issue

Fixed an issue, after a while away
Get to a known state

7 files changed, 483 insertions, 186 deletions

diff --git a/src/main/java/bjc/everge/ControlledString.java b/src/main/java/bjc/everge/ControlledString.java
index c05e3a4..691b792 100644
--- a/src/main/java/bjc/everge/ControlledString.java
+++ b/src/main/java/bjc/everge/ControlledString.java
@@ -73,14 +73,14 @@ public class ControlledString {
 			if (i < 0) {
 				String msg = String.format("Control argument index must be greater than 0 (was %d)", i);
 
-				throw new IllegalArgumentException(msg);
+				throw new IndexOutOfBoundsException(msg);
 			}
 
 			if (i > args.length) {
 				String msg = String.format("Control argument index must be less than %d (was %d)",
 						args.length, i);
 
-				throw new IllegalArgumentException(msg);
+				throw new IndexOutOfBoundsException(msg);
 			}
 
 			return args[i];
diff --git a/src/main/java/bjc/everge/Everge.java b/src/main/java/bjc/everge/Everge.java
index 5ba9e4b..d9cf65f 100644
--- a/src/main/java/bjc/everge/Everge.java
+++ b/src/main/java/bjc/everge/Everge.java
@@ -1,15 +1,10 @@
 package bjc.everge;
 
 import java.io.*;
-
-import java.nio.charset.Charset;
-
+import java.nio.charset.*;
 import java.nio.file.*;
-
 import java.util.*;
-
 import java.util.concurrent.locks.*;
-
 import java.util.regex.*;
 
 /**
@@ -39,8 +34,8 @@ public class Everge {
 	// Options for doing repl-pairs
 	private ReplOpts ropts = new ReplOpts();
 
-	// Loaded repl-pairs
-	private List<ReplPair> lrp = new ArrayList<>();
+	// Pair repository
+	private ReplSet replSet = new ReplSet();
 
 	// Input status
 	private InputStatus inputStat = InputStatus.ALL;
@@ -52,7 +47,7 @@ public class Everge {
 	private boolean printNL = true;
 
 	// Verbosity level
-	private int verbosity = 0;
+	private int verbosity;
 
 	// The pattern to use for REGEX input mode
 	private String pattern;
@@ -67,11 +62,27 @@ public class Everge {
 	/**
 	 * Stream to use for normal output.
 	 */
-	public PrintStream outStream = System.out;
+	private PrintStream outStream = System.out;
 	/**
 	 * Stream to use for error output.
 	 */
-	public PrintStream errStream = System.err;
+	private LogStream errStream = new LogStream(System.err);
+
+	public void setOutput(PrintStream out) {
+		outStream = out;
+	}
+
+	public void setOutput(OutputStream out) {
+		outStream = new PrintStream(out);
+	}
+
+	public void setError(PrintStream err) {
+		errStream = new LogStream(err);
+	}
+
+	public void setError(OutputStream err) {
+		errStream = new LogStream(new PrintStream(err));
+	}
 
 	/**
 	 * Main method for front end,
@@ -96,9 +107,20 @@ public class Everge {
 		List<String> errs = new ArrayList<>();
 
 		boolean stat = processArgs(errs, args);
+		if (verbosity >= 2) {
+			String argString = args.length > 0 ? "arguments" : "argument";
+
+			errStream.infof("[INFO] Processed %d %s\n", args.length, argString);
+			int argc = 0;
+			if (verbosity >= 3) {
+				String arg = args[argc++];
+				errStream.tracef("[TRACE]\tArg %d: '%s\n", argc, arg);
+			}
+		}
+
 		if (!stat) {
 			for (String err : errs) {
-				errStream.println(err);
+				errStream.errorf("%s\n", err);
 			}
 		}
 
@@ -125,174 +147,201 @@ public class Everge {
 			// Process CLI args
 			while(argQue.size() > 0) {
 				String arg = argQue.pop();
+				
+				retStat = processArg(errs, retStat, arg);
+			}
+		} finally {
+			argLock.writeLock().unlock();
+		}
+
+		return retStat;
+	}
+
+	private boolean processArg(List<String> errs, boolean retStat, String arg) {
+		if (arg.equals("--")) {
+			doingArgs = false;
+			return retStat;
+		}
+
+		// Process an argument
+		if (doingArgs && arg.startsWith("-")) {
+			String argName = arg;
+			String argBody = "";
+
+			// Process arguments to arguments 
+			int idx = arg.indexOf("=");
+			if (idx != -1) {
+				argName = arg.substring(0, idx);
+				argBody = arg.substring(idx + 1);
+			}
 
-				if (arg.equals("--")) {
-					doingArgs = false;
-					continue;
+			switch (argName) {
+			case "-n":
+			case "--newline":
+				printNL = true;
+				break;
+			case "-N":
+			case "--no-newline":
+				printNL = false;
+				break;
+			case "-v":
+			case "--verbose":
+				verbosity += 1;
+				errStream.louder();
+				System.err.printf("[TRACE] Incremented verbosity\n");
+				break;
+			case "-q":
+			case "--quiet":
+				verbosity -= 1;
+				errStream.quieter();
+				System.err.printf("[TRACE] Decremented verbosity\n");
+				break;
+			case "--verbosity":
+				if (argQue.size() < 1) {
+					errs.add("[ERROR] No parameter to --verbosity");
+					retStat = false;
+					break;
+				}
+				argBody = argQue.pop();
+			case "-V":
+				try {
+					verbosity = Integer.parseInt(argBody);
+					errStream.verbosity(verbosity);
+					System.err.printf("[TRACE] Set verbosity to %d\n", verbosity);
+				} catch (NumberFormatException nfex) {
+					String msg = String.format("[ERROR] Invalid verbosity: '%s' is not an integer",
+							argBody);
+					errs.add(msg);
+					retStat = false;
 				}
+				break;
+			case "--pattern":
+				if (argQue.size() < 1) {
+					errs.add("[ERROR] No parameter to --pattern");
+					retStat = false;
+					break;
+				}
+				argBody = argQue.pop();
+			case "-p":
+				try {
+					pattern = argBody;
+
+					Pattern.compile(argBody);
+				} catch (PatternSyntaxException psex) {
+					String msg = String.format("[ERROR] Pattern '%s' is invalid: %s",
+							pattern, psex.getMessage());
+					errs.add(msg);
+					retStat = false;
+				}
+				break;
+			case "--file":
+				if (argQue.size() < 1) {
+					errs.add("[ERROR] No argument to --file");
+					retStat = false;
+					break;
+				}
+				argBody = argQue.pop();
+			case "-f":
+				try (FileInputStream fis = new FileInputStream(argBody);
+						Scanner scn = new Scanner(fis)) {
+					List<ReplError> ferrs = new ArrayList<>();
 
-				// Process an argument
-				if (doingArgs && arg.startsWith("-")) {
-					String argName = arg;
-					String argBody = "";
+					List<ReplPair> lrp = new ArrayList<>();
+					lrp = ReplPair.readList(lrp, scn, ferrs, ropts);
 
-					// Process arguments to arguments 
-					int idx = arg.indexOf("=");
-					if (idx != -1) {
-						argName = arg.substring(0, idx);
-						argBody = arg.substring(idx + 1);
-					}
+					if (ferrs.size() > 0) {
+						StringBuilder sb = new StringBuilder();
+						
+						String errString = "an error";
+						if (ferrs.size() > 1) errString = String.format("%d errors");
 
-					switch (argName) {
-					case "-n":
-					case "--newline":
-						printNL = true;
-						break;
-					case "-N":
-					case "--no-newline":
-						printNL = false;
-						break;
-					case "-v":
-					case "--verbose":
-						verbosity += 1;
-						break;
-					case "-q":
-					case "--quiet":
-						verbosity -= 1;
-						break;
-					case "--verbosity":
-						if (argQue.size() < 1) {
-							errs.add("[ERROR] No parameter to --verbosity");
-							retStat = false;
-							break;
-						}
-						argBody = argQue.pop();
-						break;
-					case "-V":
-						try {
-							verbosity = Integer.parseInt(argBody);
-						} catch (NumberFormatException nfex) {
-							String msg = String.format("[ERROR] Invalid verbosity: '%s' is not an integer",
-									argBody);
-							errs.add(msg);
-							retStat = false;
-						}
-						break;
-					case "--pattern":
-						if (argQue.size() < 1) {
-							errs.add("[ERROR] No parameter to --pattern");
-							retStat = false;
-							break;
-						}
-						argBody = argQue.pop();
-					case "-p":
-						try {
-							pattern = argBody;
-
-							Pattern.compile(argBody);
-						} catch (PatternSyntaxException psex) {
-							String msg = String.format("[ERROR] Pattern '%s' is invalid: %s",
-									pattern, psex.getMessage());
-							errs.add(msg);
-							retStat = false;
-						}
-						break;
-					case "--file":
-						if (argQue.size() < 1) {
-							errs.add("[ERROR] No argument to --file");
-							retStat = false;
-							break;
-						}
-						argBody = argQue.pop();
-					case "-f":
-						try (FileInputStream fis = new FileInputStream(argBody);
-								Scanner scn = new Scanner(fis)) {
-							List<ReplError> ferrs = new ArrayList<>();
-
-							lrp = ReplPair.readList(lrp, scn, ferrs, ropts);
-
-							if (ferrs.size() > 0) {
-								StringBuilder sb = new StringBuilder();
-								
-								String errString = "an error";
-								if (ferrs.size() > 1) errString = String.format("%d errors");
-
-								{
-									String msg = String.format(
-											"[ERROR] Encountered %s parsing data file'%s'\n",
-											errString, argBody);
-									sb.append(msg);
-								}
-
-								for (ReplError err : ferrs) {
-									sb.append(String.format("\t%s\n", err));
-								}
-
-								errs.add(sb.toString());
-								retStat = false;
-							}
-						} catch (FileNotFoundException fnfex) {
-							String msg = String.format("[ERROR] Could not open data file '%s' for input",
-									argBody);
-							errs.add(msg);
-							retStat = false;
-						} catch (IOException ioex) {
-							String msg = String.format("[ERROR] Unknown I/O error reading data file '%s': %s",
-									argBody, ioex.getMessage());
-							errs.add(msg);
-							retStat = false;
-						}
-						break;
-					case "--arg-file":
-						if (argQue.size() < 1) {
-							errs.add("[ERROR] No argument to --arg-file");
-							break;
-						}
-						argBody = argQue.pop();
-					case "-F":
-						try (FileInputStream fis = new FileInputStream(argBody);
-								Scanner scn = new Scanner(fis)) {
-							List<String> sl = new ArrayList<>();
-
-							while (scn.hasNextLine()) {
-								String ln = scn.nextLine().trim();
-
-								if (ln.equals(""))      continue;
-								if (ln.startsWith("#")) continue;
-
-								sl.add(ln);
-							}
-
-							processArgs(sl.toArray(new String[0]));
-						} catch (FileNotFoundException fnfex) {
-							String msg = String.format("[ERROR] Could not open argument file '%s' for input", argBody);
-							errs.add(msg);
-							retStat = false;
-						} catch (IOException ioex) {
-							String msg = String.format("[ERROR] Unknown I/O error reading input file '%s': %s",
-									argBody, ioex.getMessage());
-							errs.add(msg);
-							retStat = false;
-						}
-						break;
-					default:
 						{
-							String msg = String.format("[ERROR] Unrecognised CLI argument name '%s'\n", argName);
-							errs.add(msg);
-							retStat = false;
+							String msg = String.format(
+									"[ERROR] Encountered %s parsing data file'%s'\n",
+									errString, argBody);
+							sb.append(msg);
+						}
+
+						for (ReplError err : ferrs) {
+							sb.append(String.format("\t%s\n", err));
 						}
+
+						errs.add(sb.toString());
+						retStat = false;
 					}
-				} else {
-					// Strip off an escaped initial dash
-					if (arg.startsWith("\\-")) arg = arg.substring(1);
 
-					processInputFile(arg);
+					replSet.addPairs(lrp);
+				} catch (FileNotFoundException fnfex) {
+					String msg = String.format("[ERROR] Could not open data file '%s' for input",
+							argBody);
+					errs.add(msg);
+					retStat = false;
+				} catch (IOException ioex) {
+					String msg = String.format("[ERROR] Unknown I/O error reading data file '%s': %s",
+							argBody, ioex.getMessage());
+					errs.add(msg);
+					retStat = false;
+				}
+				break;
+			case "--arg-file":
+				if (argQue.size() < 1) {
+					errs.add("[ERROR] No argument to --arg-file");
+					break;
+				}
+				argBody = argQue.pop();
+			case "-F":
+				try (FileInputStream fis = new FileInputStream(argBody);
+						Scanner scn = new Scanner(fis)) {
+					List<String> sl = new ArrayList<>();
+
+					while (scn.hasNextLine()) {
+						String ln = scn.nextLine().trim();
+
+						if (ln.equals(""))      continue;
+						if (ln.startsWith("#")) continue;
+
+						sl.add(ln);
+					}
+
+					processArgs(sl.toArray(new String[0]));
+				} catch (FileNotFoundException fnfex) {
+					String msg = String.format("[ERROR] Could not open argument file '%s' for input", argBody);
+					errs.add(msg);
+					retStat = false;
+				} catch (IOException ioex) {
+					String msg = String.format("[ERROR] Unknown I/O error reading input file '%s': %s",
+							argBody, ioex.getMessage());
+					errs.add(msg);
+					retStat = false;
+				}
+				break;
+			case "--input-status":
+				if (argQue.size() < 1) {
+					errs.add("[ERROR] No argument to --input-status");
+					break;
+				}
+				argBody = argQue.pop();
+			case "-I":
+				try {
+					inputStat = InputStatus.valueOf(argBody.toUpperCase());
+				} catch (IllegalArgumentException iaex) {
+					String msg = String.format("[ERROR] '%s' is not a valid input status", argBody);
+					errs.add(msg);
+				}
+				break;
+			default:
+				{
+					String msg = String.format("[ERROR] Unrecognised CLI argument name '%s'\n", argName);
+					errs.add(msg);
+					retStat = false;
 				}
 			}
-		} finally {
-			argLock.writeLock().unlock();
-		}
+		} else {
+			// Strip off an escaped initial dash
+			if (arg.startsWith("\\-")) arg = arg.substring(1);
 
+			processInputFile(arg);
+		}
 		return retStat;
 	}
 
@@ -309,7 +358,7 @@ public class Everge {
 		boolean stat = processInputFile(errs, fle);
 		if (!stat) {
 			for (String err : errs) {
-				errStream.println(err);
+				errStream.errorf("%s\n", err);
 			}
 		}
 
@@ -392,10 +441,12 @@ public class Everge {
 		try {
 			String strang = inp;
 
-			for (ReplPair rp : lrp) {
-				strang = rp.apply(strang);
+			if (verbosity >= 3) {
+				errStream.infof("[INFO] Processing replacements for string '%s' in mode \n", strang);
 			}
 
+			strang = replSet.apply(inp);
+
 			outStream.print(strang);
 			if (printNL) outStream.println();
 		} finally {
@@ -407,12 +458,19 @@ public class Everge {
 	private void loadQueue(String... args) {
 		boolean doArgs = true;
 		for (String arg : args) {
-			if (arg.equals("--")) doArgs = false;
+			if (arg.equals("--")) {
+				doArgs = false;
+			}
 
 			// Handle things like -nNv correctly
 			if (doArgs) {
 				if (arg.startsWith("-") && !arg.startsWith("--")) {
 					char[] car = arg.substring(1).toCharArray();
+
+					if (verbosity >= 3) {
+						errStream.infof("[INFO] Adding stream of args: %s", car);
+					}
+
 					for (char c : car) {
 						String argstr = String.format("-%c", c);
 						argQue.add(argstr);
diff --git a/src/main/java/bjc/everge/LogStream.java b/src/main/java/bjc/everge/LogStream.java
new file mode 100644
index 0000000..5df1047
--- /dev/null
+++ b/src/main/java/bjc/everge/LogStream.java
@@ -0,0 +1,183 @@
+package bjc.everge;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * Simple class used for logging with various levels.
+ *
+ * @author Ben Culkin
+ */
+public class LogStream {
+	/**
+	 * Log level for printing nothing.
+	 */
+	public static final int NOTHING = -1;
+
+	/**
+	 * Log level for printing only fatal errors.
+	 */
+	public static final int FATAL = 0;
+
+	/**
+	 * Log level for printing all errors.
+	 */
+	public static final int ERROR = 1;
+
+	/**
+	 * Log level for printing warnings.
+	 */
+	public static final int WARN = 2;
+
+	/**
+	 * Log level for printing info messages.
+	 */
+	public static final int INFO = 3;
+
+	/**
+	 * Log level for printing debug messages.
+	 */
+	public static final int DEBUG = 4;
+
+	/**
+	 * Log level for printing trace messages.
+	 */
+	public static final int TRACE = 5;
+
+	private int verbosity;
+
+	private PrintStream output;
+
+	/**
+	 * Create a new log stream.
+	 *
+	 * Defaults to printing only fatal errors.
+	 *
+	 * @param out
+	 * 	The output stream to place things into.
+	 */
+	public LogStream(PrintStream out) {
+		output = out;
+		verbosity = FATAL;
+	}
+
+	/**
+	 * Create a new log stream.
+	 *
+	 * @param out
+	 * 	The output stream to place things into.
+	 * @param level
+	 * 	The verbosity level. Use the constants in this class for the values.
+	 */
+	public LogStream(PrintStream out, int level) {
+		output = out;
+		verbosity = level;
+	}
+
+	public int verbosity() {
+		return verbosity;
+	}
+
+	public void verbosity(int verb) {
+		verbosity = verb;
+	}
+
+	public void louder() {
+		louder(1);
+	}
+
+	public void louder(int amt) {
+		verbosity += amt;
+	}
+
+	public void quieter() {
+		quieter(1);
+	}
+
+	public void quieter(int amt) {
+		verbosity -= amt;
+	}
+
+	/**
+	 * Print a message that will always be visible.
+	 *
+	 * @param msg
+	 * 	The message to print.
+	 */
+	public void print(String msg) {
+		output.print(msg);
+	}
+
+	/**
+	 * Print a formatted message that will always be visible.
+	 *
+	 * @param msg
+	 * 	The format string for the message to print.
+	 *
+	 * @param args
+	 * 	The arguments to the format string.
+	 */
+	public void printf(String msg, Object... args) {
+		output.printf(msg, args);
+	}
+
+	public void message(int lvl, String msg) {
+		if (verbosity >= lvl) {
+			output.print(msg);
+		}
+	}
+
+	public void messagef(int lvl, String msg, Object... args) {
+		if (verbosity >= lvl) {
+			output.printf(msg, args);
+		}
+	}
+
+	public void fatal(String msg) {
+		message(FATAL, msg);
+	}
+
+	public void fatalf(String msg, Object... args) {
+		messagef(FATAL, msg, args);
+	}
+
+	public void error(String msg) {
+		message(ERROR, msg);
+	}
+
+	public void errorf(String msg, Object... args) {
+		messagef(ERROR, msg, args);
+	}
+
+	public void warn(String msg) {
+		message(WARN, msg);
+	}
+
+	public void warnf(String msg, Object... args) {
+		messagef(WARN, msg, args);
+	}
+
+	public void info(String msg) {
+		message(INFO, msg);
+	}
+
+	public void infof(String msg, Object... args) {
+		messagef(INFO, msg, args);
+	}
+
+	public void debug(String msg) {
+		message(DEBUG, msg);
+	}
+
+	public void debugf(String msg, Object...args) {
+		messagef(DEBUG, msg, args);
+	}
+
+	public void trace(String msg) {
+		message(TRACE, msg);
+	}
+
+	public void tracef(String msg, Object... args) {
+		messagef(TRACE, msg, args);
+	}
+}
diff --git a/src/main/java/bjc/everge/MirrorOutputStream.java b/src/main/java/bjc/everge/MirrorOutputStream.java
new file mode 100644
index 0000000..6718bd7
--- /dev/null
+++ b/src/main/java/bjc/everge/MirrorOutputStream.java
@@ -0,0 +1,46 @@
+package bjc.everge;
+
+import java.io.*;
+import java.util.*;
+
+public class MirrorOutputStream extends OutputStream {
+	private List<OutputStream> streams;
+
+	public MirrorOutputStream(OutputStream... strams) {
+		streams = new ArrayList<>();
+
+		for (OutputStream stram : strams) {
+			streams.add(stram);
+		}
+	}
+
+	public void close() throws IOException {
+		for (OutputStream stream : streams) {
+			stream.close();
+		}
+	}
+
+	public void flush() throws IOException {
+		for (OutputStream stream : streams) {
+			stream.flush();
+		}
+	}
+
+	public void write(byte[] ba) throws IOException {
+		for (OutputStream stream : streams) {
+			stream.write(ba);
+		}
+	}
+
+	public void write(byte[] ba, int off, int len) throws IOException {
+		for (OutputStream stream : streams) {
+			stream.write(ba, off, len);
+		}
+	}
+
+	public void write(int b) throws IOException {
+		for (OutputStream stream : streams) {
+			stream.write(b);
+		}
+	}
+}
diff --git a/src/main/java/bjc/everge/ReplPair.java b/src/main/java/bjc/everge/ReplPair.java
index 4425da9..0d028a6 100644
--- a/src/main/java/bjc/everge/ReplPair.java
+++ b/src/main/java/bjc/everge/ReplPair.java
@@ -457,7 +457,9 @@ public class ReplPair implements Comparable<ReplPair>, UnaryOperator<String> {
 			if (!inp.matches(guard)) return inp;
 		}
 
-		return inp.replaceAll(find, replace);
+		String res = inp.replaceAll(find, replace);
+
+		return res;
 	}
 
 	@Override
diff --git a/src/main/java/bjc/everge/ReplSet.java b/src/main/java/bjc/everge/ReplSet.java
index 819779d..f759e8e 100644
--- a/src/main/java/bjc/everge/ReplSet.java
+++ b/src/main/java/bjc/everge/ReplSet.java
@@ -91,7 +91,9 @@ public class ReplSet {
 		String ret = val;
 
 		for (ReplPair par : parList) {
-			ret = par.apply(ret);
+			String tmp = par.apply(ret);
+
+			ret = tmp;
 		}
 
 		return ret;
diff --git a/src/test/java/bjc/everge/EvergeTest.java b/src/test/java/bjc/everge/EvergeTest.java
index 109992a..0a69e3a 100644
--- a/src/test/java/bjc/everge/EvergeTest.java
+++ b/src/test/java/bjc/everge/EvergeTest.java
@@ -1,15 +1,10 @@
 package bjc.everge;
 
-import bjc.everge.TestUtils;
+import bjc.everge.*;
 
-import java.io.ByteArrayOutputStream;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.PrintStream;
+import java.io.*;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Scanner;
+import java.util.*;
 
 import static bjc.everge.TestUtils.*;
 
@@ -49,18 +44,29 @@ public class EvergeTest {
 	@Test
 	public void testLoad() {
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		ByteArrayOutputStream errBaos = new ByteArrayOutputStream();
+
+		OutputStream normOut = new MirrorOutputStream(baos, System.out);
+		OutputStream normErr = new MirrorOutputStream(errBaos, System.err);
 
 		Everge evg = new Everge();
-		evg.outStream = new PrintStream(baos);
+		evg.setOutput(normOut);
+		evg.setError(normErr);
 
+		//evg.processArgs("--verbosity", "3");
 		List<String> errs = new ArrayList<>();
-		boolean stat = evg.processArgs(errs, "-vv", "--file", "data/test/evg-test1.rp",
+		boolean stat = evg.processArgs(errs, "--input-status",  "line", "--file", "data/test/evg-test1.rp",
 				"data/test/evg-test1.inp");
 		if (!stat) {
 			System.err.println("[ERROR] Did not succesfully process args");
 			for (String err : errs) {
 				System.err.println(err);
 			}
+			System.err.println("[ERROR] Normal Output:\n--------------------");
+			System.err.println(baos.toString().trim());
+			System.err.println("--------------------\n[ERROR] Error Output:\n------------------");
+			System.err.println(errBaos.toString().trim());
+			System.err.println("--------------------");
 
 			assertTrue(false);
 		}