argument, String partOfWord, ArgumentIterator iterator)
+ {
+ return firstParser.complete(null, partOfWord, iterator);
+ }
+ }
+
/**
*
* Makes it possible to convert several (or zero) {@link String}s into a single {@code T} value.
@@ -525,6 +673,16 @@ ParameterArity parameterArity()
{
return ParameterArity.AT_LEAST_ONE_ARGUMENT;
}
+
+ /**
+ * @param argument the argument that was matched
+ * @param partOfWord a part of a parameter
+ * @param iterator current iterator
+ */
+ Iterable complete(@Nullable Argument argument, String partOfWord, ArgumentIterator iterator)
+ {
+ return Collections.emptyList();
+ }
}
@CheckReturnValue
@@ -596,7 +754,7 @@ static final class HelpParser extends InternalStringParser
@Override
String parse(ArgumentIterator arguments, String previousOccurance, Argument argumentSettings, Locale locale) throws ArgumentException
{
- throw arguments.currentParser().helpFor(arguments, locale);
+ throw arguments.currentHolder().parser().helpFor(arguments, locale);
}
@Override
@@ -616,43 +774,21 @@ String metaDescription(Argument argumentSettings)
{
return "";
}
- }
-
- /**
- * Runs a {@link Runnable} when {@link StringParser#parse(String, Locale) parse} is invoked.
- */
- static final class RunnableParser extends InternalStringParser
- {
- final Runnable target;
-
- RunnableParser(Runnable target)
- {
- this.target = target;
- }
@Override
- Object parse(ArgumentIterator arguments, Object previousOccurance, Argument argumentSettings, Locale locale) throws ArgumentException
+ Iterable complete(Argument argument, String partOfWord, ArgumentIterator iterator)
{
- target.run();
- return null;
- }
-
- @Override
- String descriptionOfValidValues(Argument argumentSettings, Locale locale)
- {
- return "";
- }
-
- @Override
- Object defaultValue()
- {
- return null;
- }
+ if(iterator.hasNext())
+ {
+ iterator.next();
+ }
+ CommandLineParserInstance rootParser = iterator.currentHolder().rootParser();
+ SortedSet suggestions = new TreeSet<>();
+ Optional lastCommand = iterator.lastCommand();
+ if(lastCommand.isPresent())
+ return rootParser.completer().complete(lastCommand.get().command.parser(), partOfWord, suggestions, iterator);
- @Override
- String metaDescription(Argument argumentSettings)
- {
- return "";
+ return rootParser.completer().complete(iterator.currentHolder().parser(), partOfWord, suggestions, iterator);
}
}
@@ -712,6 +848,12 @@ String describeValue(List value)
}
return sb.toString();
}
+
+ @Override
+ Iterable complete(Argument> argument, String partOfWord, ArgumentIterator iterator)
+ {
+ return elementParser.complete(null, partOfWord, iterator);
+ }
}
/**
@@ -868,12 +1010,19 @@ static final class RepeatedArgumentParser extends ListParser
super(parser);
}
+ @SuppressWarnings("unchecked")
@Override
List parse(final ArgumentIterator arguments, List previouslyCreatedList, final Argument argumentSettings, Locale locale)
throws ArgumentException
{
T parsedValue = elementParser().parse(arguments, null, argumentSettings, locale);
+ if(elementParser() instanceof Command)
+ {
+ // Re-check as parse is recursive in this case
+ previouslyCreatedList = (List) arguments.currentHolder().getValue(argumentSettings);
+ }
+
List listToStoreRepeatedValuesIn = previouslyCreatedList;
if(listToStoreRepeatedValuesIn == null)
{
@@ -942,9 +1091,10 @@ Map parse(final ArgumentIterator arguments, Map previousMap, final A
{
map = defaultValue();
}
-
String keyValue = arguments.next();
- String key = getKey(keyValue, argumentSettings);
+ String separator = argumentSettings.separator();
+ String key = getKey(keyValue, separator)
+ .orElseThrow(() -> withMessage(format(UserErrors.MISSING_KEY_VALUE_SEPARATOR, argumentSettings, keyValue, separator)));
K parsedKey = keyParser.parse(key, locale);
V oldValue = map.get(parsedKey);
@@ -972,15 +1122,14 @@ Map parse(final ArgumentIterator arguments, Map previousMap, final A
/**
* Fetch "key" from "key=value"
*/
- private String getKey(String keyValue, Argument argumentSettings) throws ArgumentException
+ private Optional getKey(String keyValue, String separator) throws ArgumentException
{
if(valueParser.parameterArity() == ParameterArity.NO_ARGUMENTS)
- return keyValue;// Consume the whole string as the key as there's no value to parse
- String separator = argumentSettings.separator();
+ return Optional.of(keyValue);// Consume the whole string as the key as there's no value to parse
int keyEndIndex = keyValue.indexOf(separator);
if(keyEndIndex == -1)
- throw withMessage(format(UserErrors.MISSING_KEY_VALUE_SEPARATOR, argumentSettings, keyValue, separator));
- return keyValue.substring(0, keyEndIndex);
+ return Optional.empty();
+ return Optional.of(keyValue.substring(0, keyEndIndex));
}
/**
@@ -1024,6 +1173,41 @@ String metaDescription(Argument argumentSettings)
String valueMeta = valueParser.metaDescription(argumentSettings);
return keyMeta + separator + valueMeta;
}
+
+ @Override
+ Iterable complete(Argument> arg, String partOfWord, ArgumentIterator iterator)
+ {
+ List suggestions = new ArrayList<>();
+ String separator = arg.separator();
+ Optional maybeKey = getKey(partOfWord, separator);
+ if(!maybeKey.isPresent())
+ {
+ for(String suggestion : keyParser.complete(partOfWord))
+ {
+ suggestions.add(iterator.getCurrentArgumentName() + suggestion + arg.separator());
+ }
+ }
+ else
+ {
+ String key = maybeKey.get();
+ String value = getValue(key, partOfWord, arg);
+
+ for(String suggestion : valueParser.complete(null, value, iterator))
+ {
+ // Because = is a word boundary by default in bash
+ if(arg.separator().equals(MapArgumentBuilder.DEFAULT_KV_SEPARATOR)
+ && (!value.isEmpty() || !iterator.isCompletingGeneratedSuggestion))
+ {
+ suggestions.add(suggestion);
+ }
+ else
+ {
+ suggestions.add(iterator.getCurrentArgumentName() + key + arg.separator() + suggestion);
+ }
+ }
+ }
+ return suggestions;
+ }
}
static final class StringParserBridge extends InternalStringParser implements StringParser
@@ -1090,5 +1274,17 @@ public String toString()
{
return descriptionOfValidValues(Locale.US);
}
+
+ @Override
+ public Iterable complete(String partOfWord)
+ {
+ return stringParser.complete(partOfWord);
+ }
+
+ @Override
+ Iterable complete(Argument argument, String partOfWord, ArgumentIterator iterator)
+ {
+ return stringParser.complete(partOfWord);
+ }
}
}
diff --git a/jargo/src/main/java/se/softhouse/jargo/Usage.java b/jargo/src/main/java/se/softhouse/jargo/Usage.java
index 48f5db36..9b9bf26e 100644
--- a/jargo/src/main/java/se/softhouse/jargo/Usage.java
+++ b/jargo/src/main/java/se/softhouse/jargo/Usage.java
@@ -13,10 +13,10 @@
package se.softhouse.jargo;
import static java.lang.Math.max;
+import static java.lang.System.lineSeparator;
import static java.util.Collections.unmodifiableList;
import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.toList;
-import static se.softhouse.common.strings.StringsUtil.NEWLINE;
import static se.softhouse.common.strings.StringsUtil.repeat;
import static se.softhouse.jargo.Argument.IS_INDEXED;
import static se.softhouse.jargo.Argument.IS_OF_VARIABLE_ARITY;
@@ -84,6 +84,7 @@ public String toString()
private final transient ProgramInformation program;
private final transient boolean forCommand;
// TODO(jontejj): try getting the correct value automatically, if not possible fall back to 80
+ // exec tput cols 2> /dev/tty
private transient int columnWidth = 80;
private transient String fromSerializedUsage = null;
@@ -119,7 +120,10 @@ public String toString()
private Usage(String fromSerializedUsage)
{
// All these are unused as the usage is already constructed
- this(null, null, null, false);
+ this.unfilteredArguments = null;
+ this.locale = null;
+ this.program = null;
+ this.forCommand = false;
this.fromSerializedUsage = fromSerializedUsage;
}
@@ -224,7 +228,7 @@ private void appendUsageTo(Appendable builder) throws IOException
private String header()
{
if(forCommand) // Commands get their header from their meta description
- return hasArguments() ? NEWLINE : "";
+ return hasArguments() ? lineSeparator() : "";
String mainUsage = UsageTexts.USAGE_HEADER + program.programName();
@@ -233,11 +237,11 @@ private String header()
mainUsage += UsageTexts.ARGUMENT_INDICATOR;
}
- mainUsage += NEWLINE + Lines.wrap(program.programDescription(), columnWidth, locale);
+ mainUsage += lineSeparator() + Lines.wrap(program.programDescription(), columnWidth, locale);
if(hasArguments())
{
- mainUsage += NEWLINE + UsageTexts.ARGUMENT_HEADER + ":" + NEWLINE;
+ mainUsage += lineSeparator() + UsageTexts.ARGUMENT_HEADER + ":" + lineSeparator();
}
return mainUsage;
@@ -340,7 +344,7 @@ private Row usageForArgument(final Argument arg)
{
row.descriptionColumn.append(Lines.wrap(description, indexOfDescriptionColumn, columnWidth, locale));
addIndicators(arg, row.descriptionColumn);
- row.descriptionColumn.append(NEWLINE);
+ row.descriptionColumn.append(lineSeparator());
valueExplanation(arg, row.descriptionColumn);
}
else
@@ -379,15 +383,15 @@ private void valueExplanation(final Argument arg, StringBuilder target)
{
if(!validValuesDescription.isEmpty())
{
- target.append(NEWLINE);
+ target.append(lineSeparator());
}
String spaces = repeat(" ", UsageTexts.DEFAULT_VALUE_START.length());
- descriptionOfDefaultValue = descriptionOfDefaultValue.replace(NEWLINE, NEWLINE + spaces);
+ descriptionOfDefaultValue = descriptionOfDefaultValue.replace(lineSeparator(), lineSeparator() + spaces);
target.append(UsageTexts.DEFAULT_VALUE_START).append(descriptionOfDefaultValue);
}
}
- private static final Pattern BY_NEWLINE = Pattern.compile(NEWLINE);
+ private static final Pattern BY_NEWLINE = Pattern.compile(lineSeparator());
private void appendRowTo(Row row, Appendable target) throws IOException
{
@@ -406,13 +410,13 @@ private void appendRowTo(Row row, Appendable target) throws IOException
target.append(repeat(" ", paddingWidth));
target.append(descriptionLines.next());
}
- target.append(NEWLINE);
+ target.append(lineSeparator());
}
while(descriptionLines.hasNext())
{
target.append(repeat(" ", indexOfDescriptionColumn));
target.append(descriptionLines.next());
- target.append(NEWLINE);
+ target.append(lineSeparator());
}
}
diff --git a/jargo/src/main/java/se/softhouse/jargo/internal/Texts.java b/jargo/src/main/java/se/softhouse/jargo/internal/Texts.java
index c729de0e..8271c29c 100644
--- a/jargo/src/main/java/se/softhouse/jargo/internal/Texts.java
+++ b/jargo/src/main/java/se/softhouse/jargo/internal/Texts.java
@@ -12,7 +12,11 @@
*/
package se.softhouse.jargo.internal;
-import se.softhouse.common.strings.StringsUtil;
+import static java.lang.System.lineSeparator;
+import static se.softhouse.common.strings.StringsUtil.TAB;
+
+import java.nio.charset.StandardCharsets;
+
import se.softhouse.jargo.Argument;
import se.softhouse.jargo.ArgumentBuilder;
import se.softhouse.jargo.ArgumentException;
@@ -21,9 +25,6 @@
import se.softhouse.jargo.StringParser;
import se.softhouse.jargo.StringParsers;
-import static se.softhouse.common.strings.StringsUtil.NEWLINE;
-import static se.softhouse.common.strings.StringsUtil.TAB;
-
/**
* Contains {@link String#format(String, Object...)} ready strings.
*/
@@ -74,7 +75,7 @@ private UsageTexts()
/**
* Indicates that if a file called with what comes after the @ sign exists, arguments should
- * be read from it (in {@link StringsUtil#UTF8}) before continuing on with the parsing.
+ * be read from it (in {@link StandardCharsets#UTF_8}) before continuing on with the parsing.
*/
public static final String FILE_REFERENCE_PREFIX = "@";
}
@@ -100,7 +101,7 @@ private UserErrors()
* Used by {@link CommandLineParser#parse(String...)}.
*
*/
- public static final String SUGGESTION = "Didn't expect %s, did you mean one of these?" + NEWLINE + TAB + "%s";
+ public static final String SUGGESTION = "Didn't expect %s, did you mean one of these?" + lineSeparator() + TAB + "%s";
/**
*
@@ -243,6 +244,13 @@ private ProgrammaticErrors()
* {@link ArgumentBuilder#variableArity()}
*/
public static final String SEVERAL_VARIABLE_ARITY_PARSERS = "Several unnamed arguments are configured to receive a variable arity of parameters: %s";
+
+ /**
+ * Parameter %s = a list with all parameters that is configured with
+ * {@link ArgumentBuilder#repeated()} and are {@link ArgumentBuilder#names(String...) indexed}
+ */
+ public static final String INDEXED_AND_REPEATED_ARGUMENT = "Argument: %s is both indexed and repeated. If you expect more than one parameter, use arity(...) / variableArity() instead.";
+
/**
* Parameter %s = a name that would cause ambiguous parsing
*/
@@ -280,6 +288,6 @@ private ProgrammaticErrors()
* Parameter %s = the illegal argument that the {@link CommandLineParser} wasn't
* configured to handle
*/
- public static final String ILLEGAL_ARGUMENT = "%s was not found in this result at all. Did you perhaps forget to add it to withArguments(...)?";
+ public static final String ILLEGAL_ARGUMENT = "%s was not found in this result at all. Did you perhaps forget to add it to withArguments(...)? Another failure cause could be that you are expecting to access arguments to subcommands from a parent command, that is not enabled by default.";
}
}
diff --git a/jargo/src/test/java/se/softhouse/common/classes/ClassesTest.java b/jargo/src/test/java/se/softhouse/common/classes/ClassesTest.java
index f6b30d6c..95563016 100644
--- a/jargo/src/test/java/se/softhouse/common/classes/ClassesTest.java
+++ b/jargo/src/test/java/se/softhouse/common/classes/ClassesTest.java
@@ -18,12 +18,12 @@
import org.junit.Test;
-import se.softhouse.common.testlib.Launcher;
-import se.softhouse.common.testlib.Launcher.LaunchedProgram;
-
import com.google.common.testing.NullPointerTester;
import com.google.common.testing.NullPointerTester.Visibility;
+import se.softhouse.common.testlib.Launcher;
+import se.softhouse.common.testlib.Launcher.LaunchedProgram;
+
/**
* Tests for {@link Classes}
*/
@@ -34,11 +34,10 @@ public void testThatMainClassNameIsExampleProgram() throws IOException, Interrup
{
LaunchedProgram threadedProgram = Launcher.launch(ExampleProgram.class);
- // TODO(jontejj): add assertion once
- // http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8021205 has been solved
- // assertThat(threadedProgram.errors()).as("Errors detected in subprogram: " +
- // threadedProgram.errors() + ". Debuginfo:"
- // + threadedProgram.debugInformation()).isEmpty();
+ // If you get problems with this line, try to update your java environment. See
+ // http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8021205 for more details.
+ assertThat(threadedProgram.errors())
+ .as("Errors detected in subprogram: " + threadedProgram.errors() + ". Debuginfo:" + threadedProgram.debugInformation()).isEmpty();
assertThat(threadedProgram.output()).isEqualTo("ExampleProgram");
}
@@ -47,11 +46,10 @@ public void testThatFetchingMainClassNameWorksFromANewThread() throws IOExceptio
{
LaunchedProgram threadedProgram = Launcher.launch(ThreadedProgram.class);
- // TODO(jontejj): add assertion once
- // http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8021205 has been solved
- // assertThat(threadedProgram.errors()).as("Errors detected in subprogram: " +
- // threadedProgram.errors() + ". Debuginfo:"
- // + threadedProgram.debugInformation()).isEmpty();
+ // If you get problems with this line, try to update your java environment. See
+ // http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8021205 for more details.
+ assertThat(threadedProgram.errors())
+ .as("Errors detected in subprogram: " + threadedProgram.errors() + ". Debuginfo:" + threadedProgram.debugInformation()).isEmpty();
assertThat(threadedProgram.output()).isEqualTo("ThreadedProgram");
}
diff --git a/jargo/src/test/java/se/softhouse/common/classes/NoMainAvailable.java b/jargo/src/test/java/se/softhouse/common/classes/NoMainAvailable.java
index 42e44890..e8e565b1 100644
--- a/jargo/src/test/java/se/softhouse/common/classes/NoMainAvailable.java
+++ b/jargo/src/test/java/se/softhouse/common/classes/NoMainAvailable.java
@@ -12,6 +12,8 @@
*/
package se.softhouse.common.classes;
+import static org.fest.assertions.Assertions.assertThat;
+
public final class NoMainAvailable
{
private NoMainAvailable()
@@ -38,8 +40,10 @@ public void run()
}
try
{
- Classes.mainClassName();
- System.err.print("Requesting name of mainClass after main thread has died should trigger an IllegalStateException");
+ String mainClassName = Classes.mainClassName();
+ assertThat(mainClassName)
+ .describedAs("Requesting name of mainClass after main thread has died should trigger an IllegalStateException") //
+ .isNull();
}
catch(IllegalStateException expected)
{
diff --git a/jargo/src/test/java/se/softhouse/common/collections/CharacterTrieBenchmark.java b/jargo/src/test/java/se/softhouse/common/collections/CharacterTrieBenchmark.java
index 411976df..fe95dbb2 100644
--- a/jargo/src/test/java/se/softhouse/common/collections/CharacterTrieBenchmark.java
+++ b/jargo/src/test/java/se/softhouse/common/collections/CharacterTrieBenchmark.java
@@ -15,7 +15,6 @@
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.Set;
import java.util.SortedMap;
import com.google.caliper.Param;
@@ -88,7 +87,7 @@ public int timePrefixSearching(int reps)
int dummy = 0;
for(int i = 0; i < reps; i++)
{
- for(Entry entry : type.entriesWithPrefix(elements, "100"))
+ for(Entry entry : type.entriesWithPrefix(elements, "100").entrySet())
{
if(entry != null)
{
@@ -103,37 +102,40 @@ private enum CollectionType
{
MAP
{
- @Override
+
+ @Override
Map createMap(Map elements)
{
return Maps.newTreeMap();
}
- @Override
- Set> entriesWithPrefix(Map elements, String prefix)
+ @Override
+ Map entriesWithPrefix(Map elements, String prefix)
{
- return ((SortedMap) elements).tailMap(prefix).entrySet();
+ return ((SortedMap) elements).tailMap(prefix);
}
- },
- CHARACTER_TRIE
- {
- @Override
+ },
+
+ CHARACTER_TRIE{
+
+ @Override
Map createMap(Map elements)
{
return CharacterTrie.newTrie(elements);
}
- @Override
- Set> entriesWithPrefix(Map elements, String prefix)
+ @Override
+ Map entriesWithPrefix(Map elements, String prefix)
{
return ((CharacterTrie) elements).getEntriesWithPrefix(prefix);
}
- };
- abstract Map createMap(Map elements);
+ };
+
+ abstract Map createMap(Map elements);
- abstract Set> entriesWithPrefix(Map elements, String prefix);
+ abstract Map entriesWithPrefix(Map elements, String prefix);
}
diff --git a/jargo/src/test/java/se/softhouse/common/collections/CharacterTrieTest.java b/jargo/src/test/java/se/softhouse/common/collections/CharacterTrieTest.java
index bce16bab..f00d4c92 100644
--- a/jargo/src/test/java/se/softhouse/common/collections/CharacterTrieTest.java
+++ b/jargo/src/test/java/se/softhouse/common/collections/CharacterTrieTest.java
@@ -16,6 +16,7 @@
import static org.fest.assertions.MapAssert.entry;
import static org.junit.Assert.fail;
+import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map.Entry;
@@ -160,7 +161,7 @@ public void testFindingAllEntriesWithPrefix() throws Exception
trie.put("fooo", BAR);
trie.put("fooos", ZOO);
- Set actualEntries = valuesInSet(trie.getEntriesWithPrefix("fooo"));
+ Collection actualEntries = trie.getEntriesWithPrefix("fooo").values();
assertThat(actualEntries).containsOnly(BAR, ZOO);
}
@@ -188,7 +189,7 @@ public void testThatFindingAllEntriesWithEmptyPrefixReturnsTheWholeTrie() throws
// Make sure equals of Entry isn't fooling us
CharacterTrie copy = CharacterTrie.newTrie(trie);
- assertThat(trie.getEntriesWithPrefix("")).isEqualTo(copy.entrySet());
+ assertThat(trie.getEntriesWithPrefix("")).isEqualTo(copy.getEntriesWithPrefix(""));
}
@Test
diff --git a/jargo/src/test/java/se/softhouse/common/guavaextensions/Suppliers2Test.java b/jargo/src/test/java/se/softhouse/common/guavaextensions/Suppliers2Test.java
index 27f499d2..01fe0660 100644
--- a/jargo/src/test/java/se/softhouse/common/guavaextensions/Suppliers2Test.java
+++ b/jargo/src/test/java/se/softhouse/common/guavaextensions/Suppliers2Test.java
@@ -24,6 +24,9 @@
import com.google.common.testing.NullPointerTester;
import com.google.common.testing.NullPointerTester.Visibility;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import se.softhouse.common.testlib.Explanation;
+
/**
* Tests for {@link Suppliers2}
*/
@@ -73,6 +76,7 @@ public void testThatRepeatedElementsReturnCorrectNumberOfInstances()
}
@Test(expected = IllegalArgumentException.class)
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatNegativeRepeatsIsIllegal()
{
Suppliers2.ofRepeatedElements(FOO_SUPPLIER, -1);
diff --git a/jargo/src/test/java/se/softhouse/common/numbers/NumberTypeTest.java b/jargo/src/test/java/se/softhouse/common/numbers/NumberTypeTest.java
index 9d295d35..9b698ffe 100644
--- a/jargo/src/test/java/se/softhouse/common/numbers/NumberTypeTest.java
+++ b/jargo/src/test/java/se/softhouse/common/numbers/NumberTypeTest.java
@@ -13,6 +13,7 @@
package se.softhouse.common.numbers;
import static java.lang.String.format;
+import static java.lang.System.lineSeparator;
import static org.fest.assertions.Assertions.assertThat;
import static org.fest.assertions.Fail.fail;
import static se.softhouse.common.numbers.NumberType.BIG_DECIMAL;
@@ -22,7 +23,6 @@
import static se.softhouse.common.numbers.NumberType.LONG;
import static se.softhouse.common.numbers.NumberType.OUT_OF_RANGE;
import static se.softhouse.common.numbers.NumberType.SHORT;
-import static se.softhouse.common.strings.StringsUtil.NEWLINE;
import static se.softhouse.common.testlib.Locales.SWEDISH;
import java.math.BigDecimal;
@@ -36,6 +36,9 @@
import com.google.common.testing.NullPointerTester;
import com.google.common.testing.NullPointerTester.Visibility;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import se.softhouse.common.testlib.Explanation;
+
/**
* Tests for {@link NumberType}
*/
@@ -96,6 +99,7 @@ public void testNumbersAtBounds()
}
}
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
private void testUnlimitedType(NumberType type)
{
try
@@ -142,6 +146,7 @@ public void testThatDescriptionOfValidValuesReturnsHumanReadableStrings() throws
}
@Test(expected = IllegalArgumentException.class)
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatEmptyInputThrows() throws Exception
{
BYTE.parse("");
@@ -192,6 +197,7 @@ public void testThatToStringReturnsName()
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testInvalidShortNumbers()
{
List invalidInput = Arrays.asList(Short.MIN_VALUE - 1, Short.MAX_VALUE + 1);
@@ -210,6 +216,7 @@ public void testInvalidShortNumbers()
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testInvalidIntegerNumbers()
{
List invalidInput = Arrays.asList((long) Integer.MIN_VALUE - 1, (long) Integer.MAX_VALUE + 1);
@@ -228,6 +235,7 @@ public void testInvalidIntegerNumbers()
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testInvalidLongNumbers()
{
List invalidInput = Arrays.asList(BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE), biggerThanLong);
@@ -257,6 +265,7 @@ public void testThatNullContractsAreFollowed()
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatUnparsableIntegerGeneratesProperErrorMessage() throws Exception
{
try
@@ -269,7 +278,7 @@ public void testThatUnparsableIntegerGeneratesProperErrorMessage() throws Except
/**
* @formatter.off
*/
- assertThat(e).hasMessage("'123a' is not a valid integer (Localization: English)" + NEWLINE +
+ assertThat(e).hasMessage("'123a' is not a valid integer (Localization: English)" + lineSeparator() +
" ^");
/**
* @formatter.on
@@ -278,6 +287,7 @@ public void testThatUnparsableIntegerGeneratesProperErrorMessage() throws Except
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatUnparsableBigIntegerGeneratesProperErrorMessage() throws Exception
{
try
@@ -290,7 +300,7 @@ public void testThatUnparsableBigIntegerGeneratesProperErrorMessage() throws Exc
/**
* @formatter.off
*/
- assertThat(e).hasMessage("'12.3' is not a valid big-integer (Localization: English)" + NEWLINE +
+ assertThat(e).hasMessage("'12.3' is not a valid big-integer (Localization: English)" + lineSeparator() +
" ^");
/**
* @formatter.on
@@ -299,6 +309,7 @@ public void testThatUnparsableBigIntegerGeneratesProperErrorMessage() throws Exc
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatDecimalSeparatorCausesParseErrorForDiscreetTypes() throws Exception
{
List> discreetTypes = Arrays.>asList(BYTE, SHORT, INTEGER, LONG, BIG_INTEGER);
diff --git a/jargo/src/test/java/se/softhouse/common/strings/DescribersTest.java b/jargo/src/test/java/se/softhouse/common/strings/DescribersTest.java
index 96453a6a..d5747584 100644
--- a/jargo/src/test/java/se/softhouse/common/strings/DescribersTest.java
+++ b/jargo/src/test/java/se/softhouse/common/strings/DescribersTest.java
@@ -12,26 +12,11 @@
*/
package se.softhouse.common.strings;
-import com.google.common.testing.NullPointerTester;
-import com.google.common.testing.NullPointerTester.Visibility;
-import org.junit.Test;
-import se.softhouse.common.strings.Describers.BooleanDescribers;
-import se.softhouse.common.testlib.Locales;
-import se.softhouse.common.testlib.ResourceLoader;
-
-import java.io.File;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
import static com.google.common.collect.Maps.newLinkedHashMap;
+import static java.lang.System.lineSeparator;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
-import static org.fest.assertions.Assertions.*;
+import static org.fest.assertions.Assertions.assertThat;
import static org.junit.Assert.fail;
import static se.softhouse.common.strings.Describers.asFunction;
import static se.softhouse.common.strings.Describers.booleanAsEnabledDisabled;
@@ -42,9 +27,28 @@
import static se.softhouse.common.strings.Describers.numberDescriber;
import static se.softhouse.common.strings.Describers.toStringDescriber;
import static se.softhouse.common.strings.Describers.withConstantString;
-import static se.softhouse.common.strings.StringsUtil.NEWLINE;
import static se.softhouse.common.testlib.Locales.TURKISH;
+import java.io.File;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import org.junit.Test;
+
+import com.google.common.testing.NullPointerTester;
+import com.google.common.testing.NullPointerTester.Visibility;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import se.softhouse.common.strings.Describers.BooleanDescribers;
+import se.softhouse.common.testlib.Explanation;
+import se.softhouse.common.testlib.Locales;
+import se.softhouse.common.testlib.ResourceLoader;
+
/**
* Tests for {@link Describers}
*/
@@ -188,7 +192,7 @@ public void testMapDescriberForValuesAndKeysWithCustomSeparator()
Describer> customValueKeySeparator = mapDescriber( Describers.withConstantString("foo"),
Describers.withConstantString("bar"), ":");
String describedMap = customValueKeySeparator.describe(values, locale);
- assertThat(describedMap).isEqualTo("foo:bar" + NEWLINE + "foo:bar");
+ assertThat(describedMap).isEqualTo("foo:bar" + lineSeparator() + "foo:bar");
assertThat(customValueKeySeparator.describe(Collections.emptyMap(), locale)).isEqualTo("Empty map");
@@ -205,10 +209,11 @@ public void testMapDescriberForValuesAndKeysWithCustomSeparator()
// Test with custom valueDescriber, custom keyDescriber
Describer> customValueAndKey = mapDescriber( Describers.withConstantString("foo"),
Describers.withConstantString("bar"));
- assertThat(customValueAndKey.describe(values, locale)).contains("foo=bar" + NEWLINE + "foo=bar");
+ assertThat(customValueAndKey.describe(values, locale)).contains("foo=bar" + lineSeparator() + "foo=bar");
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatMissingKeyThrows()
{
Map map = newLinkedHashMap();
diff --git a/jargo/src/test/java/se/softhouse/common/strings/StringsUtilTest.java b/jargo/src/test/java/se/softhouse/common/strings/StringsUtilTest.java
index 095cc0a2..d115ae5f 100644
--- a/jargo/src/test/java/se/softhouse/common/strings/StringsUtilTest.java
+++ b/jargo/src/test/java/se/softhouse/common/strings/StringsUtilTest.java
@@ -19,32 +19,26 @@
import static se.softhouse.common.strings.StringsUtil.closestMatches;
import static se.softhouse.common.strings.StringsUtil.numberToPositionalString;
import static se.softhouse.common.strings.StringsUtil.pointingAtIndex;
-import static se.softhouse.common.strings.StringsUtil.spaces;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Locale;
+import java.util.SortedSet;
import org.junit.Test;
-import se.softhouse.common.testlib.Explanation;
-
import com.google.common.testing.NullPointerTester;
import com.google.common.testing.NullPointerTester.Visibility;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import se.softhouse.common.testlib.Explanation;
/**
* Tests for {@link StringsUtil}
*/
public class StringsUtilTest
{
- @Test
- public void testThatSpacesCreatesFiveSpaces()
- {
- assertThat(spaces(5)).isEqualTo(" ");
- }
-
@Test
public void testLevenshteinDistance()
{
@@ -59,6 +53,22 @@ public void testLevenshteinDistance()
assertThat(StringsUtil.levenshteinDistance("hello", "hallo")).isEqualTo(1);
}
+ @Test
+ public void testThatAllPrefixesAreReturned() throws Exception
+ {
+ List strings = asList("logging", "logger", "mologger");
+ SortedSet prefixes = StringsUtil.prefixes("log", strings);
+ assertThat(prefixes).containsOnly("logging", "logger");
+ }
+
+ @Test
+ public void testThatAllPrefixesAreReturnedIgnoringCase() throws Exception
+ {
+ List strings = asList("logging", "logger", "mologger");
+ SortedSet prefixes = StringsUtil.prefixesIgnoringCase("Log", strings, Locale.US);
+ assertThat(prefixes).containsOnly("Logging", "Logger");
+ }
+
@Test
public void testLevenshteinDistanceWithADistance()
{
@@ -150,6 +160,7 @@ public void testThatPointingAtIndexProducesSpacesBeforeThePointer()
}
@Test(expected = IllegalArgumentException.class)
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatNegativeNumberCantBePositional()
{
numberToPositionalString(-1);
diff --git a/jargo/src/test/java/se/softhouse/jargo/ArityArgumentTest.java b/jargo/src/test/java/se/softhouse/jargo/ArityArgumentTest.java
index 8af90e13..598dff5f 100644
--- a/jargo/src/test/java/se/softhouse/jargo/ArityArgumentTest.java
+++ b/jargo/src/test/java/se/softhouse/jargo/ArityArgumentTest.java
@@ -23,14 +23,14 @@
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Set;
import org.junit.Test;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import se.softhouse.common.testlib.Explanation;
-import se.softhouse.jargo.CommandLineParserInstance.ArgumentIterator;
import se.softhouse.jargo.internal.Texts.ProgrammaticErrors;
import se.softhouse.jargo.internal.Texts.UserErrors;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
/**
* Tests for {@link ArgumentBuilder#arity(int)} and {@link ArgumentBuilder#variableArity()}
@@ -72,6 +72,7 @@ public void testThatArityAndSplitWithIncompabilityIsEnforced()
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatArityOfOneIsForbidden()
{
try
@@ -105,8 +106,12 @@ public void testThatUsageTextForArityLooksGood()
Argument> foo = stringArgument("--foo").arity(3).description("MetaDescShouldBeDisplayedThreeTimes").build();
Argument> bar = integerArgument("--bar").arity(2).description("MetaDescShouldBeDisplayedTwoTimes").build();
Argument> zoo = integerArgument("--zoo").variableArity().description("MetaDescShouldIndicateVariableAmount").build();
+ Argument trans = integerArgument("--trans").variableArity().transform(l -> l.size())
+ .description("MetaDescShouldIndicateVariableAmount").build();
+ Argument transTwo = integerArgument("--trans-two").arity(2).transform(l -> l.size()).description("MetaDescShouldBeDisplayedTwoTimes")
+ .build();
Argument> boo = integerArgument().variableArity().description("MetaDescShouldIndicateVariableAmount").build();
- Usage usage = CommandLineParser.withArguments(foo, bar, zoo, boo).usage();
+ Usage usage = CommandLineParser.withArguments(foo, bar, zoo, trans, transTwo, boo).usage();
assertThat(usage).isEqualTo(expected("metaDescriptionsForArityArgument"));
}
@@ -120,7 +125,7 @@ public void testUsageTextForEmptyList()
@Test
public void testThatNrOfRemainingArgumentsGivesTheCorrectCapacity()
{
- ArgumentIterator args = ArgumentIterator.forArguments(Arrays.asList("foo"), Collections.>emptyMap());
+ ArgumentIterator args = ArgumentIterator.forArguments(Arrays.asList("foo"));
assertThat(args.nrOfRemainingArguments()).isEqualTo(1);
args.next(); // Consume one argument
assertThat(args.nrOfRemainingArguments()).isEqualTo(0);
@@ -145,4 +150,11 @@ public void testThatTwoUnnamedVariableArityArgumentsIsIllegal()
assertThat(expected).hasMessage(String.format(ProgrammaticErrors.SEVERAL_VARIABLE_ARITY_PARSERS, "[, ]"));
}
}
+
+ @Test
+ public void testThatArityCanBeTransformedToUniqueValues()
+ {
+ Set numbers = integerArgument().variableArity().unique().parse("123", "24", "123");
+ assertThat(numbers).containsOnly(123, 24);
+ }
}
diff --git a/jargo/src/test/java/se/softhouse/jargo/BashCompletionTest.java b/jargo/src/test/java/se/softhouse/jargo/BashCompletionTest.java
new file mode 100644
index 00000000..9f6e2190
--- /dev/null
+++ b/jargo/src/test/java/se/softhouse/jargo/BashCompletionTest.java
@@ -0,0 +1,221 @@
+/* Copyright 2018 jonatanjonsson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package se.softhouse.jargo;
+
+import static java.util.Collections.emptyList;
+import static org.fest.assertions.Assertions.assertThat;
+import static se.softhouse.jargo.Arguments.enumArgument;
+import static se.softhouse.jargo.Arguments.stringArgument;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+import org.junit.Test;
+
+import com.google.common.io.MoreFiles;
+
+import se.softhouse.common.strings.StringsUtil;
+import se.softhouse.common.testlib.Launcher;
+import se.softhouse.common.testlib.Launcher.LaunchedProgram;
+import se.softhouse.jargo.commands.Build.BuildTarget;
+import se.softhouse.jargo.commands.CommandWithArgument;
+import se.softhouse.jargo.commands.Commit.Repository;
+import se.softhouse.jargo.commands.Git;
+import se.softhouse.jargo.commands.Mvn;
+import se.softhouse.jargo.stringparsers.EnumArgumentTest.Action;
+
+/**
+ * Tests that the correct words are suggested for
+ * {@link Completers#bashCompleter(java.util.function.Supplier, java.util.function.Consumer, Runnable)
+ * bash-completion} support
+ */
+public class BashCompletionTest
+{
+ final CommandLineParser parser = CommandLineParser.withCommands(new Git(new Repository())).andArguments(Git.MESSAGE);
+
+ final List currentDirFiles;
+
+ public BashCompletionTest() throws IOException
+ {
+ currentDirFiles = MoreFiles.listFiles(Paths.get(".")).stream().map(p -> p.getFileName().toString()).collect(Collectors.toList());
+ }
+
+ @Test
+ public void testThatNoCompletionsDoesNothing() throws Exception
+ {
+ Argument arg = stringArgument("-j").build();
+ ParsedArguments parsedArguments = CommandLineParser.withArguments(arg).noCompleter().parse("-j", "hello");
+ assertThat(parsedArguments.get(arg)).isEqualTo("hello");
+ }
+
+ @Test
+ public void testThatCommandNameIsCompletedCorrectly() throws Exception
+ {
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "commi");
+ assertThat(suggestions).containsOnly("commit ");
+
+ suggestions = FakeCompleter.complete(parser, "git", "com");
+ assertThat(suggestions).containsOnly("commit ");
+
+ suggestions = FakeCompleter.complete(parser, "git", "lo");
+ assertThat(suggestions).containsOnly("log ");
+
+ suggestions = FakeCompleter.complete(parser, "--");
+ assertThat(suggestions).containsOnly("--message ");
+
+ suggestions = FakeCompleter.complete(parser, "");
+ assertThat(suggestions).containsOnly("--message ", "-m ", "git ");
+
+ suggestions = FakeCompleter.complete(parser, "git", "commit", "--author=j", "--no");
+ assertThat(suggestions).isEmpty();
+ }
+
+ @Test
+ public void testThatCompletingAnArgToACommandWorks() throws Exception
+ {
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "commit", "--am");
+ assertThat(suggestions).containsOnly("--amend ");
+ }
+
+ @Test
+ public void testThatCompletingARequiredArgForACommandWorks() throws Exception
+ {
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "commit", "--auth");
+ assertThat(suggestions).containsOnly("--author=");
+ }
+
+ @Test
+ public void testThatBothSubCommandsAndRegularArgAreSuggested() throws Exception
+ {
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "");
+ assertThat(suggestions).containsOnly("commit ", "log ", "merge ", "--message ", "-m ");
+ }
+
+ @Test
+ public void testThatArgsWithEqualsSeparatorAreNotSuggestedTwice() throws Exception
+ {
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "commit", "--author=");
+ assertThat(suggestions).isEmpty();
+ }
+
+ @Test
+ public void testThatCommandsWithRequiredArgsBeingCompletedAreCompletedCorrectly() throws Exception
+ {
+ Argument action = enumArgument(Action.class, "-a").separator("=").required().build();
+ CommandWithArgument commandWithArgument = new CommandWithArgument<>("command", action);
+
+ CommandLineParser commandParser = CommandLineParser.withCommands(commandWithArgument);
+ SortedSet suggestions = FakeCompleter.complete(commandParser, "command", "-a=");
+ assertThat(suggestions).containsOnly("start", "stop", "restart");
+ }
+
+ @Test
+ public void testThatBothArgsAndVariableArgsAreSuggestedBeforeEnteringVariableArgs() throws Exception
+ {
+ TreeSet expectedSuggestions = new TreeSet<>(currentDirFiles);
+ // Does not contain --author as it's already parsed
+ expectedSuggestions.addAll(Arrays.asList("--amend ", "--message ", "-m ", "log ", "merge "));
+
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "commit", "--author=j", "");
+ assertThat(suggestions).isEqualTo(expectedSuggestions);
+
+ // Once variable args have been given, no other args should be suggested
+ suggestions = FakeCompleter.complete(parser, "git", "commit", "--author=j", "file", "");
+ assertThat(suggestions).isEqualTo(new TreeSet<>(currentDirFiles));
+ }
+
+ @Test
+ public void testThatEmptyParameterWithNoCompletionsLeadsToNoSuggestions() throws Exception
+ {
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "commit", "--message", "");
+ assertThat(suggestions).isEmpty();
+ }
+
+ @Test
+ public void testThatEmptyParameterWithNoCompletionsLeadsToNoSuggestionsAlsoAfterRequiredArgs() throws Exception
+ {
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "commit", "--author=joj", "--message", "");
+ assertThat(suggestions).isEmpty();
+ }
+
+ @Test
+ public void testThatVariableArityArgsCanBeCompleted() throws Exception
+ {
+ CommandLineParser p = CommandLineParser.withArguments(enumArgument(Action.class).variableArity().build());
+ SortedSet suggestions = FakeCompleter.complete(p, "stop", "re");
+ assertThat(suggestions).containsOnly("restart");
+ }
+
+ @Test
+ public void testThatVariableArityArgsCanBeSuggestedSeveralTimes() throws Exception
+ {
+ SortedSet suggestions = FakeCompleter.complete(parser, "git", "commit", "--author=j", "pom.xml", "");
+ assertThat(suggestions).isEqualTo(new TreeSet<>(currentDirFiles));
+ }
+
+ @Test
+ public void testThatCustomCompleterIsUsedInsteadOfDefault() throws Exception
+ {
+ CommandLineParser p = CommandLineParser.withArguments(enumArgument(Action.class)
+ .completer((str) -> StringsUtil.prefixes(str, Collections.singleton("reab"))).variableArity().build());
+ SortedSet suggestions = FakeCompleter.complete(p, "stop", "re");
+ assertThat(suggestions).containsOnly("reab");
+
+ suggestions = FakeCompleter.complete(p, "stop", "restart", "r");
+ assertThat(suggestions).containsOnly("reab");
+ }
+
+ @Test
+ public void testThatSeveralCommandHierarchiesInTheSameParserSupportCompletions() throws Exception
+ {
+ Repository repo = new Repository();
+ BuildTarget target = new BuildTarget();
+ CommandLineParser twoCommandsParser = CommandLineParser.withCommands(new Git(repo), new Mvn(target));
+
+ SortedSet suggestions = FakeCompleter.complete(twoCommandsParser, "git", "log", "mvn", "log");
+ assertThat(suggestions).containsOnly("log ");
+ }
+
+ public static void main(String[] args)
+ {
+ Argument shouldNotParse = stringArgument("--comp").transform((a) -> {
+ if(a != null)
+ {
+ System.out.println(a);
+ }
+ return a;
+ }).build();
+ Argument stuff = stringArgument("--complete-me").build();
+ CommandLineParser.withArguments(shouldNotParse, stuff).parse(args);
+ }
+
+ @Test
+ public void testThatCompleterParsesArgumentsBeforeTheArgumentThatShouldBeCompleted() throws Exception
+ {
+ String[] args = {"--comp", "hello", "--compl"};
+ Map fakeEnv = FakeCompleter.fakeEnv("ProgramName", " ", args);
+ LaunchedProgram launchedProgram = Launcher.launch(emptyList(), fakeEnv, BashCompletionTest.class, args);
+ assertThat(launchedProgram.errors()).isEmpty();
+ assertThat(launchedProgram.exitCode()).isEqualTo(0);
+ assertThat(launchedProgram.output()).isEqualTo("hello" + System.lineSeparator() + "--complete-me " + System.lineSeparator());
+ }
+}
diff --git a/jargo/src/test/java/se/softhouse/jargo/CombinedOptionsTest.java b/jargo/src/test/java/se/softhouse/jargo/CombinedOptionsTest.java
index faab41d4..ac8cc056 100644
--- a/jargo/src/test/java/se/softhouse/jargo/CombinedOptionsTest.java
+++ b/jargo/src/test/java/se/softhouse/jargo/CombinedOptionsTest.java
@@ -19,6 +19,8 @@
import org.junit.Test;
+import se.softhouse.jargo.commands.CommandWithTwoArguments;
+
/**
* Tests for a batch of short-named optional arguments.
* For instance when "-fs" is used instead of "-f -s"
@@ -93,4 +95,15 @@ protected String commandName()
// Also verify that the argument is parsed by it's rightful recipient
assertThat(args.get(programArgument)).isEqualTo(1);
}
+
+ @Test
+ public void testThatBatchOfOptionFlagsWorksForCommand() throws Exception
+ {
+ Argument option = Arguments.optionArgument("-o").build();
+ Argument secondOption = Arguments.optionArgument("-s").build();
+ CommandWithTwoArguments runWithOptions = new CommandWithTwoArguments<>("run", option, secondOption);
+ CommandLineParser.withCommands(runWithOptions).parse("run", "-so");
+ assertThat(runWithOptions.parsedObject).isTrue();
+ assertThat(runWithOptions.parsedObjectTwo).isTrue();
+ }
}
diff --git a/jargo/src/test/java/se/softhouse/jargo/CommandLineParserTest.java b/jargo/src/test/java/se/softhouse/jargo/CommandLineParserTest.java
index b9af3ea0..5ee472a2 100644
--- a/jargo/src/test/java/se/softhouse/jargo/CommandLineParserTest.java
+++ b/jargo/src/test/java/se/softhouse/jargo/CommandLineParserTest.java
@@ -141,7 +141,7 @@ public void testThatCloseMatchIsSuggestedForTypos()
}
catch(ArgumentException expected)
{
- assertThat(expected).hasMessage(String.format(UserErrors.SUGGESTION, "-number", "--number"));
+ assertThat(expected).hasMessage(String.format(UserErrors.SUGGESTION, "-number", "--number "));
}
}
@@ -348,6 +348,7 @@ public void testThatAllArgumentsAreTreatedAsIndexedArgumentsAfterEndOfOptions()
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatInvalidArgumentsAddedLaterOnDoesNotWreckTheExistingParser() throws Exception
{
Argument number = integerArgument("-n").build();
@@ -370,6 +371,7 @@ public void testThatInvalidArgumentsAddedLaterOnDoesNotWreckTheExistingParser()
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatInvalidCommandsAddedLaterOnDoesNotWreckTheExistingParser() throws Exception
{
BuildTarget target = new BuildTarget();
@@ -419,6 +421,7 @@ public void testThatParserIsModifiableAfterFailedAddArgumentOperation() throws E
{
testThatNullDoesNotCauseOtherConcurrentUpdatesToFail(new ParserInvocation>(){
@Override
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void invoke(CommandLineParser parser, Argument value)
{
parser.andArguments(value);
@@ -522,6 +525,7 @@ public void testThatArgumentBuilderTransfersPropertiesWhenBuilderIsChanged() thr
}
@Test
+ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED", justification = Explanation.FAIL_FAST)
public void testThatNamesAreNotAllowedToHaveSpacesInThem() throws Exception
{
try
diff --git a/jargo/src/test/java/se/softhouse/jargo/FakeCompleter.java b/jargo/src/test/java/se/softhouse/jargo/FakeCompleter.java
new file mode 100644
index 00000000..20ef5547
--- /dev/null
+++ b/jargo/src/test/java/se/softhouse/jargo/FakeCompleter.java
@@ -0,0 +1,70 @@
+/* Copyright 2018 jonatanjonsson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package se.softhouse.jargo;
+
+import static org.fest.assertions.Assertions.assertThat;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.SortedSet;
+import java.util.concurrent.atomic.AtomicReference;
+
+import se.softhouse.jargo.ArgumentException;
+import se.softhouse.jargo.ArgumentExceptions;
+import se.softhouse.jargo.CommandLineParser;
+import se.softhouse.jargo.Completers;
+
+public final class FakeCompleter
+{
+ private FakeCompleter()
+ {
+ }
+
+ public static SortedSet completeWithSeparator(CommandLineParser parser, String separator, String ... args)
+ {
+ String programName = "program";
+ Map fakeEnv = fakeEnv(programName, separator, args);
+ AtomicReference> suggestions = new AtomicReference>(null);
+ try
+ {
+ parser.completer(Completers.bashCompleter(() -> fakeEnv, suggestions::set, () -> {
+ throw ArgumentExceptions.withMessage("Done with completions");
+ })).parse();
+ }
+ catch(ArgumentException expected)
+ {
+ if(!"Done with completions".equals(expected.getMessage()))
+ throw expected;
+ }
+ assertThat(suggestions.get()).describedAs("No suggestions set. Completer failure").isNotNull();
+ return suggestions.get();
+ }
+
+ public static SortedSet complete(CommandLineParser parser, String ... args)
+ {
+ return completeWithSeparator(parser, " ", args);
+ }
+
+ public static Map fakeEnv(String programName, String separator, String ... args)
+ {
+ Objects.requireNonNull(programName);
+ Map fakeEnv = new HashMap<>();
+ String compLine = programName + " " + String.join(separator, args);
+ fakeEnv.put("COMP_LINE", compLine);
+ fakeEnv.put("COMP_POINT", "" + compLine.length());
+ return fakeEnv;
+ }
+}
diff --git a/jargo/src/test/java/se/softhouse/jargo/IgnoringCaseTest.java b/jargo/src/test/java/se/softhouse/jargo/IgnoringCaseTest.java
index 867865ac..8f07f3de 100644
--- a/jargo/src/test/java/se/softhouse/jargo/IgnoringCaseTest.java
+++ b/jargo/src/test/java/se/softhouse/jargo/IgnoringCaseTest.java
@@ -15,9 +15,11 @@
import static org.fest.assertions.Assertions.assertThat;
import static se.softhouse.jargo.Arguments.integerArgument;
import static se.softhouse.jargo.Arguments.optionArgument;
+import static se.softhouse.jargo.Arguments.stringArgument;
import static se.softhouse.jargo.CommandLineParser.withArguments;
import java.util.Map;
+import java.util.SortedSet;
import org.junit.Test;
@@ -46,6 +48,13 @@ public void testWithPropertyMap() throws ArgumentException
assertThat(numbers.get("foo")).isNull();
}
+ @Test
+ public void testThatIgnoringCaseWorksForEmptySeparator() throws ArgumentException
+ {
+ String hello = stringArgument("-a").separator("").ignoreCase().parse("-Ahello");
+ assertThat(hello).isEqualTo("hello");
+ }
+
@Test
public void testWithPropertyMapNotIgnoringCase() throws ArgumentException
{
@@ -60,6 +69,16 @@ public void testWithPropertyMapNotIgnoringCase() throws ArgumentException
assertThat(parsedArguments.get(indexed)).isEqualTo("-Bbig=5");
}
+ @Test
+ public void testThatCompletingWorksForIgnoreCaseArguments() throws Exception
+ {
+ Argument name = stringArgument("--name").ignoreCase().build();
+ CommandLineParser parser = CommandLineParser.withArguments(name);
+
+ SortedSet suggestions = FakeCompleter.complete(parser, "--Na");
+ assertThat(suggestions).containsOnly("--Name ");
+ }
+
@Test(expected = ArgumentException.class)
public void testThatLowerCaseArgumentIsNotReturnedWhenNotIgnoringCase() throws ArgumentException
{
diff --git a/jargo/src/test/java/se/softhouse/jargo/IndexedArgumentTest.java b/jargo/src/test/java/se/softhouse/jargo/IndexedArgumentTest.java
index 13b7d8b8..0835b4ac 100644
--- a/jargo/src/test/java/se/softhouse/jargo/IndexedArgumentTest.java
+++ b/jargo/src/test/java/se/softhouse/jargo/IndexedArgumentTest.java
@@ -15,23 +15,22 @@
import static org.fest.assertions.Assertions.assertThat;
import static org.fest.assertions.Fail.fail;
import static se.softhouse.jargo.Arguments.booleanArgument;
+import static se.softhouse.jargo.Arguments.enumArgument;
import static se.softhouse.jargo.Arguments.integerArgument;
import static se.softhouse.jargo.Arguments.stringArgument;
import static se.softhouse.jargo.Arguments.withParser;
import static se.softhouse.jargo.StringParsers.stringParser;
+import java.util.List;
import java.util.Locale;
+import java.util.SortedSet;
import org.junit.Test;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import se.softhouse.common.testlib.Explanation;
-import se.softhouse.jargo.Argument;
-import se.softhouse.jargo.ArgumentException;
-import se.softhouse.jargo.CommandLineParser;
-import se.softhouse.jargo.ForwardingStringParser;
-import se.softhouse.jargo.ParsedArguments;
import se.softhouse.jargo.internal.Texts.ProgrammaticErrors;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import se.softhouse.jargo.stringparsers.EnumArgumentTest.Action;
/**
*
@@ -47,17 +46,17 @@
*/
public class IndexedArgumentTest
{
+ Argument enableLogging = booleanArgument().description("Output debug information to standard out").build();
+
+ Argument port = integerArgument().defaultValue(8080).description("The port to start the server on.").build();
+
+ Argument greetingPhrase = stringArgument().description("A greeting phrase to greet new connections with").build();
+
@Test
public void testIndexedArguments() throws ArgumentException
{
String[] args = {"true", "8090", "Hello"};
- Argument enableLogging = booleanArgument().description("Output debug information to standard out").build();
-
- Argument port = integerArgument().defaultValue(8080).description("The port to start the server on.").build();
-
- Argument greetingPhrase = stringArgument().description("A greeting phrase to greet new connections with").build();
-
ParsedArguments arguments = CommandLineParser.withArguments(enableLogging, port, greetingPhrase).parse(args);
assertThat(arguments.get(enableLogging)).isTrue();
@@ -65,6 +64,35 @@ public void testIndexedArguments() throws ArgumentException
assertThat(arguments.get(greetingPhrase)).isEqualTo("Hello");
}
+ @Test
+ public void testThatOnlyCurrentlyIndexedArgumentIsSuggested() throws Exception
+ {
+ Argument action = enumArgument(Action.class).description("Output debug information to standard out").build();
+
+ CommandLineParser parser = CommandLineParser.withArguments(port, greetingPhrase, enableLogging, action);
+
+ SortedSet suggestions = FakeCompleter.complete(parser, "8080", "Hello!", "");
+ assertThat(suggestions).containsOnly("false", "true");
+
+ suggestions = FakeCompleter.complete(parser, "8080", "Hello!", "true", "");
+ assertThat(suggestions).containsOnly("start", "stop", "restart");
+ }
+
+ @Test
+ public void testThatSeveralIndexedArgumentsCanBeFinalized() throws Exception
+ {
+ Argument> firstActions = enumArgument(Action.class).arity(2).description("first").build();
+ Argument> secondActions = enumArgument(Action.class).arity(2).description("second").build();
+
+ CommandLineParser parser = CommandLineParser.withArguments(firstActions, secondActions);
+
+ ParsedArguments parsedArguments = parser.parse("start", "stop", "stop", "start");
+ assertThat(parsedArguments.get(firstActions)).containsExactly(Action.start, Action.stop);
+ assertThat(parsedArguments.get(secondActions)).containsExactly(Action.stop, Action.start);
+ SortedSet