Parse combined short options

WIP.
Error handling is actual missing.

Author: lefou

de.tototec.cmdoption/src/main/java/de/tototec/cmdoption/CmdlineParser.java

@@ -35,6 +35,7 @@
 import de.tototec.cmdoption.handler.PutIntoMapHandler;
 import de.tototec.cmdoption.handler.StringFieldHandler;
 import de.tototec.cmdoption.handler.StringMethodHandler;
+import de.tototec.cmdoption.internal.F0;
 import de.tototec.cmdoption.internal.F1;
 import de.tototec.cmdoption.internal.FList;
 import de.tototec.cmdoption.internal.I18n;
@@ -114,6 +115,8 @@ public class CmdlineParser {
 
 	private Optional<String> argsFromFilePrefix = Optional.some("@");
 
+	private Optional<String> aggregateShortOptionsWithPrefix = Optional.none();
+
 	protected CmdlineParser(final CmdlineParser parent, final String commandName, final Object commandObject) {
 		this.parent = parent;
 		debugAllowed = parent.debugAllowed;
@@ -359,9 +362,35 @@ public List<String> apply(final String arg) {
 
 		boolean helpDetected = false;
 
-		// Actually iterate over the command line elements
-		for (int index = 0; index < cmdline.length; ++index) {
-			final String param = cmdline[index];
+		final String aggregatePrefix = aggregateShortOptionsWithPrefix.getOrElse(new F0<String>() {
+			@Override
+			public String apply() {
+				return "";
+			}
+		});
+		final LinkedHashMap<String, OptionHandle> shortOptionMap = new LinkedHashMap<String, OptionHandle>();
+		final int aggregatePrefixSize = aggregatePrefix.length();
+		if (aggregateShortOptionsWithPrefix.isDefined()) {
+			final int expectedSize = 1 + aggregatePrefixSize;
+			for (final Entry<String, OptionHandle> oh : quickOptionMap.entrySet()) {
+				if (oh.getKey().startsWith(aggregatePrefix) && oh.getKey().length() == expectedSize) {
+					shortOptionMap.put(oh.getKey().substring(aggregatePrefixSize), oh.getValue());
+				}
+			}
+		}
+
+		int index = -1;
+		String[] rest = cmdline;
+
+		while (rest.length > index + 1) {
+			if (index >= 0) {
+				rest = Arrays.copyOfRange(rest, ++index, rest.length);
+			}
+			index = 0;
+
+			// Actually iterate over the command line elements
+			// for (int index = 0; index < cmdline.length; ++index) {
+			final String param = rest[index];
 			if (parseOptions && stopOption.equals(param)) {
 				parseOptions = false;
 
@@ -380,20 +409,20 @@ public List<String> apply(final String arg) {
 					helpDetected = true;
 				}
 
-				if (cmdline.length <= index + optionHandle.getArgsCount()) {
+				if (rest.length <= index + optionHandle.getArgsCount()) {
 					final PreparedI18n msg = i18n.preparetr(
 							"Missing arguments(s): {0}. Option \"{1}\" requires {2} arguments, but you gave {3}.",
 							FList.mkString(
-									Arrays.asList(optionHandle.getArgs()).subList(cmdline.length - index - 1,
+									Arrays.asList(optionHandle.getArgs()).subList(rest.length - index - 1,
 											optionHandle.getArgsCount()),
 									", "),
 							param, optionHandle
 							.getArgsCount(),
-							cmdline.length - index - 1);
+							rest.length - index - 1);
 					throw new CmdlineParserException(msg.notr(), msg.tr());
 				}
 				// slurp next cmdline arguments into option arguments
-				final String[] optionArgs = Arrays.copyOfRange(cmdline, index + 1,
+				final String[] optionArgs = Arrays.copyOfRange(rest, index + 1,
 						index + 1 + optionHandle.getArgsCount());
 				index += optionHandle.getArgsCount();
 
@@ -427,9 +456,40 @@ public List<String> apply(final String arg) {
 				}
 				// Delegate parsing of the rest of the cmdline to the command
 				commandHandle.getCmdlineParser().parse(dryrun, detectHelpAndSkipValidation,
-						Arrays.copyOfRange(cmdline, index + 1, cmdline.length));
+						Arrays.copyOfRange(rest, index + 1, rest.length));
 				// Stop parsing
 				break;
+			} else if (parseOptions
+					&& aggregateShortOptionsWithPrefix.isDefined()
+					&& param.startsWith(aggregatePrefix)
+					&& param.length() > aggregatePrefixSize + 1) {
+				// Found an aggregated short option
+				final char[] singleOptions = param.substring(aggregatePrefixSize).toCharArray();
+				// rewrite the cmdline
+				final List<String> rewritten = new LinkedList<String>();
+				int procCount = 1;
+				for (final char c : singleOptions) {
+					final OptionHandle oh = shortOptionMap.get(String.valueOf(c));
+					if (oh == null) {
+						// FIXME: unsupported aggregation found
+					}
+					if(rest.length < procCount + oh.getArgsCount()) {
+						// FIXME: missing args detected
+					}
+					// add as standalone short option
+					rewritten.add(aggregatePrefix + c);
+					for (int i = 0; i < oh.getArgsCount(); ++i) {
+						// slurp args from cmdline
+						rewritten.add(rest[i + procCount]);
+						++procCount;
+					}
+				}
+				// re-interate parsing with the modified command line
+				final String[] newRest = Arrays.copyOfRange(rest, procCount, rest.length);
+				rewritten.addAll(Arrays.asList(newRest));
+				rest = rewritten.toArray(new String[0]);
+				index = -1;
+				continue;
 
 			} else if (parameter == null && defaultCommandName != null
 					&& quickCommandMap.containsKey(defaultCommandName)) {
@@ -442,24 +502,24 @@ public List<String> apply(final String arg) {
 				}
 				// Delegate parsing of the rest of the cmdline to the command
 				commandHandle.getCmdlineParser().parse(dryrun, detectHelpAndSkipValidation,
-						Arrays.copyOfRange(cmdline, index, cmdline.length));
+						Arrays.copyOfRange(rest, index, rest.length));
 				// Stop parsing
 				break;
 
 			} else if (parameter != null) {
 				// Found a parameter
 				optionCount.put(parameter, optionCount.get(parameter) + 1);
 
-				if (cmdline.length <= index + parameter.getArgsCount() - 1) {
-					final int countOfGivenParams = cmdline.length - index;
+				if (rest.length <= index + parameter.getArgsCount() - 1) {
+					final int countOfGivenParams = rest.length - index;
 					final PreparedI18n msg = i18n.preparetr(
 							"Missing arguments: {0} Parameter requires {1} arguments, but you gave {2}.",
 							Arrays.asList(parameter.getArgs()).subList(countOfGivenParams, parameter.getArgsCount()),
 							parameter.getArgsCount(), countOfGivenParams);
 					throw new CmdlineParserException(msg.notr(), msg.tr());
 				}
 				// slurp next cmdline arguments into option arguments
-				final String[] optionArgs = Arrays.copyOfRange(cmdline, index, index + parameter.getArgsCount());
+				final String[] optionArgs = Arrays.copyOfRange(rest, index, index + parameter.getArgsCount());
 				// -1, because index gets increased by one at end of for-loop
 				index += parameter.getArgsCount() - 1;
 
@@ -704,6 +764,8 @@ protected void validateOptions() {
 				}
 			}
 		}
+		// TODO: Ensure, there are no long options, starting with the aggregated short
+		// option prefix, and when, disable this feature
 	}
 
 	protected boolean isVisible(final Class<?> baseClass, final Member element) {
@@ -1025,4 +1087,12 @@ public void setReadArgsFromFilePrefix(final String prefix) {
 		}
 	}
 
+	public void setAggregateShortOptionsWithPrefix(final String prefix) {
+		if (prefix == null || prefix.trim().isEmpty()) {
+			aggregateShortOptionsWithPrefix = Optional.none();
+		} else {
+			aggregateShortOptionsWithPrefix = Optional.some(prefix.trim());
+		}
+	}
+
 }

de.tototec.cmdoption/src/test/java/de/tototec/cmdoption/AggregateShortOptionsTest.java

@@ -0,0 +1,76 @@
+package de.tototec.cmdoption;
+
+import static de.tobiasroeser.lambdatest.Expect.expectEquals;
+import static de.tobiasroeser.lambdatest.Expect.expectFalse;
+import static de.tobiasroeser.lambdatest.Expect.expectTrue;
+
+import de.tobiasroeser.lambdatest.testng.FreeSpec;
+
+public class AggregateShortOptionsTest extends FreeSpec {
+
+	public static class Config {
+		@CmdOption(names = { "-f", "--file" }, args = { "FILE" })
+		String file = null;
+
+		@CmdOption(names = { "-l" })
+		boolean formatLong = false;
+
+		@CmdOption(names = { "-s", "--size" })
+		boolean showSize = false;
+	}
+
+	public AggregateShortOptionsTest() {
+
+		test("Setting all short options separate should work (reference test)", () -> {
+			final Config config = new Config();
+			final CmdlineParser cp = new CmdlineParser(config);
+			cp.setAggregateShortOptionsWithPrefix("-");
+			cp.parse(new String[] { "-l", "-s", "-f", "file.txt" });
+			expectTrue(config.formatLong);
+			expectTrue(config.showSize);
+			expectEquals(config.file, "file.txt");
+		});
+
+		test("Aggregation is not supported when disabled", () -> {
+			final Config config = new Config();
+			final CmdlineParser cp = new CmdlineParser(config);
+			cp.setAggregateShortOptionsWithPrefix(null);
+			intercept(CmdlineParserException.class, "Unsupported option or parameter found: -ls", () -> {
+				cp.parse(new String[] { "-ls" });
+			});
+		});
+
+		test("Combining two short options without args should work", () -> {
+			final Config config = new Config();
+			final CmdlineParser cp = new CmdlineParser(config);
+			cp.setAggregateShortOptionsWithPrefix("-");
+			cp.parse(new String[] { "-ls" });
+			expectTrue(config.formatLong);
+			expectTrue(config.showSize);
+			expectEquals(config.file, null);
+		});
+
+		test("Combining two short options with args at end should work", () -> {
+			final Config config = new Config();
+			final CmdlineParser cp = new CmdlineParser(config);
+			cp.setAggregateShortOptionsWithPrefix("-");
+			cp.parse(new String[] { "-lf", "file.txt" });
+			expectTrue(config.formatLong);
+			expectFalse(config.showSize);
+			expectEquals(config.file, "file.txt");
+		});
+
+		test("Combining two short options with args in between should work", () -> {
+			final Config config = new Config();
+			final CmdlineParser cp = new CmdlineParser(config);
+			cp.setAggregateShortOptionsWithPrefix("-");
+			cp.parse(new String[] { "-lfs", "file.txt" });
+			expectTrue(config.formatLong);
+			expectTrue(config.showSize);
+			expectEquals(config.file, "file.txt");
+		});
+
+
+	}
+
+}