@Test
public void testOptionsWithDefaultValue() {
CLI cli = CLIConfigurator.define(CommandForDefaultValueTest.class);
assertThat(cli.getOptions()).hasSize(1);
assertThat(find(cli.getOptions(), "option").getDefaultValue()).isEqualTo("bar");
assertThat(find(cli.getOptions(), "option").getName()).isEqualTo("option");
}
@Test
public void testOptionsWithDescription() {
CLI cli = CLIConfigurator.define(CommandForDescriptionTest.class);
assertThat(cli.getOptions()).hasSize(1);
assertThat(find(cli.getOptions(), "option").getDescription())
.isEqualTo("This option is awesome");
}
private void generateBuildSystem() throws MojoExecutionException {
try {
packageDirectory.mkdirs();
new File(packageDirectory, "m4").mkdirs();
targetSrcDir = new File(packageDirectory, "src");
targetSrcDir.mkdirs();
if (customPackageDirectory != null && customPackageDirectory.isDirectory()) {
FileUtils.copyDirectoryStructureIfModified(customPackageDirectory, packageDirectory);
}
if (generatedNativeSourceDirectory != null && generatedNativeSourceDirectory.isDirectory()) {
FileUtils.copyDirectoryStructureIfModified(generatedNativeSourceDirectory, targetSrcDir);
}
copyTemplateResource("readme.md", false);
copyTemplateResource("configure.ac", true);
copyTemplateResource("Makefile.am", true);
copyTemplateResource("m4/custom.m4", false);
copyTemplateResource("m4/jni.m4", false);
copyTemplateResource("m4/osx-universal.m4", false);
// To support windows based builds..
String tool = windowsBuildTool.toLowerCase().trim();
if ("detect".equals(tool)) {
copyTemplateResource("vs2008.vcproj", true);
copyTemplateResource("vs2010.vcxproj", true);
} else if ("msbuild".equals(tool)) {
copyTemplateResource("vs2010.vcxproj", true);
} else if ("vcbuild".equals(tool)) {
copyTemplateResource("vs2008.vcproj", true);
} else if ("none".equals(tool)) {
} else {
throw new MojoExecutionException(
"Invalid setting for windowsBuildTool: " + windowsBuildTool);
}
File autogen = new File(packageDirectory, "autogen.sh");
File configure = new File(packageDirectory, "configure");
if (!autogen.exists()) {
copyTemplateResource("autogen.sh", false);
cli.setExecutable(autogen);
}
if (!skipAutogen) {
if ((!configure.exists() && !CLI.IS_WINDOWS) || forceAutogen) {
try {
cli.system(packageDirectory, new String[] {"./autogen.sh"}, autogenArgs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
} catch (Exception e) {
throw new MojoExecutionException("Native build system generation failed: " + e, e);
}
}
@Test
public void testInjectionOfString() throws CLIException {
HelloClI command = new HelloClI();
CLI cli = CLIConfigurator.define(HelloClI.class);
CommandLine evaluatedCLI = cli.parse(Arrays.asList("--name", "vert.x"));
CLIConfigurator.inject(evaluatedCLI, command);
assertThat(command.run()).isEqualToIgnoringCase("Hello vert.x");
assertThat(command.name).isEqualToIgnoringCase("vert.x");
}
@Test
public void testOptionsParsedAsList() {
CLI command = CLIConfigurator.define(CommandForParsedAsList.class);
assertThat(command.getOptions()).hasSize(1);
assertThat(((TypedOption) find(command.getOptions(), "option")).getListSeparator())
.isEqualTo(":");
assertThat(find(command.getOptions(), "option").isMultiValued()).isTrue();
assertThat(((TypedOption) find(command.getOptions(), "option")).getType())
.isEqualTo(String.class);
}
public void command(CLI cli) {
Scope scope = Scope.ROOT_SCOPE;
cli.getOut().println("Root scope: ");
for (Map.Entry<String, List<Declaration>> scopeEntry : scope) {
cli.getOut().println(scopeEntry.getKey() + ": ");
for (Declaration decl : scopeEntry.getValue()) {
cli.getOut()
.println(" " + decl.getKind() + " " + decl.getName() + " (" + decl + ")");
}
}
}
@Test
public void specifyingADefaultValueForAnOption() throws Exception {
cli =
new CLI() {
{
option("-b").takingArgument("SIZE").ofType(int.class).defaultingTo(1024);
}
};
cli.parse();
assertEquals(1024, cli.get("-b"));
}
@Test
public void testUsage() {
CLI command = CLIConfigurator.define(HelloClI.class);
StringBuilder builder = new StringBuilder();
command.usage(builder);
assertThat(builder)
.containsIgnoringCase("Usage: hello -n <name>")
.containsIgnoringCase("A command saying hello.")
.containsIgnoringCase("A simple cli to wish you a good day. Pass your name with `--name`")
.containsIgnoringCase(" -n,--name <name> your name");
}
@Test
public void usingSimpleOptionSwitches() throws ParsingException {
cli =
new CLI() {
{
flag("-x").describedAs("Turns debugging on");
}
};
cli.parse("-x");
assertTrue(cli.has("-x"));
}
@Test
public void usingACustomOptionType() throws Exception {
cli =
new CLI() {
{
coerceType(BigDecimal.class).using(new BigDecimalCoercer());
option("--size VALUE").ofType(BigDecimal.class);
}
};
cli.parse("--size", "1000.00");
assertEquals(new BigDecimal("1000.00"), cli.get("--size"));
}
@Test
public void definingAnOptionWithAnAliasForm() throws Exception {
cli =
new CLI() {
{
option("-x").alias("--debug");
}
};
cli.parse("--debug");
assertTrue(cli.has("-x"));
assertTrue(cli.has("--debug"));
}
private CLI runCliWithInput(String... inputLines) {
StringBuilder builder = new StringBuilder();
for (String line : inputLines) {
builder.append(line).append(System.getProperty("line.separator"));
}
ByteArrayInputStream in = new ByteArrayInputStream(builder.toString().getBytes());
CLI cli = new CLI(in, testOut);
cli.startEventLoop();
return cli;
}
@Test
public void specifyingTheTypeOfAnOptionArgument() throws Exception {
cli =
new CLI() {
{
option("-b").takingArgument("SIZE").ofType(int.class);
}
};
cli.parse("-b", "1024");
int blockSize = cli.<Integer>get("-b");
assertEquals(1024, blockSize);
}
@Test
public void specifyingAnOptionInLiteralForm() throws Exception {
cli =
new CLI() {
{
option("-h", "--host HOSTNAME", "Hostname to bind to");
}
};
cli.parse("--host", "0.0.0.0");
assertTrue(cli.has("-h"));
assertTrue(cli.has("--host"));
assertEquals("0.0.0.0", cli.get("-h"));
}
@Test
public void usingBuiltInCoercers() throws Exception {
cli =
new CLI() {
{
option("-c").takingArgument("CLASSNAME").ofType(Class.class);
operand("file").ofType(File.class);
}
};
cli.parse("-c", "java.lang.String", "/path/to/file");
assertEquals(String.class, cli.get("-c"));
assertEquals(new File("/path/to/file"), cli.get("file"));
}
@Test
public void definingAnOptionThatExpectsAnArgument() throws Exception {
cli =
new CLI() {
{
option("-b").takingArgument("SIZE");
}
};
cli.parse("-b", "1024");
assertTrue(cli.has("-b"));
assertEquals("1024", cli.get("-b"));
}
@Test
public void specifyingTheTypeOfAPositionalArgument() throws ParsingException {
cli =
new CLI() {
{
operand("input").ofType(File.class);
}
};
cli.parse("/path/to/input");
File inputFile = cli.get("input");
assertEquals("/path/to/input", inputFile.getAbsolutePath());
}
@Test
public void usingPositionalArguments() throws Exception {
cli =
new CLI() {
{
operand("input").describedAs("The input file");
operand("output").describedAs("The output file");
}
};
cli.parse("input", "output");
assertEquals("input", cli.get("input"));
assertEquals("output", cli.get("output"));
}
@Test
public void testTypeExtraction() {
CLI command = CLIConfigurator.define(CommandForTypeExtractTest.class);
assertThat(command.getOptions()).hasSize(6);
TypedOption model = (TypedOption) find(command.getOptions(), "list");
assertThat(model.getType()).isEqualTo(String.class);
assertThat(model.isMultiValued()).isTrue();
model = (TypedOption) find(command.getOptions(), "set");
assertThat(model.getType()).isEqualTo(Character.class);
assertThat(model.isMultiValued()).isTrue();
model = (TypedOption) find(command.getOptions(), "collection");
assertThat(model.getType()).isEqualTo(Integer.class);
assertThat(model.isMultiValued()).isTrue();
model = (TypedOption) find(command.getOptions(), "tree");
assertThat(model.getType()).isEqualTo(String.class);
assertThat(model.isMultiValued()).isTrue();
model = (TypedOption) find(command.getOptions(), "al");
assertThat(model.getType()).isEqualTo(String.class);
assertThat(model.isMultiValued()).isTrue();
model = (TypedOption) find(command.getOptions(), "array");
assertThat(model.getType()).isEqualTo(Integer.TYPE);
assertThat(model.isMultiValued()).isTrue();
}
private static Arguments getArgs(final String[] args) throws Exception {
try {
return CLI.getArguments(args);
} catch (final Exception e) {
throw new Exception("Encountered an error when parsing arguments", e);
}
}
@Test
public void testHelloCLIFromClass() {
CLI command = CLIConfigurator.define(HelloClI.class);
assertThat(command.getOptions()).hasSize(1);
TypedOption option = (TypedOption) find(command.getOptions(), "name");
assertThat(option.getLongName()).isEqualToIgnoringCase("name");
assertThat(option.getShortName()).isEqualToIgnoringCase("n");
assertThat(option.getType()).isEqualTo(String.class);
assertThat(option.getArgName()).isEqualTo("name");
assertThat(option.getDescription()).isEqualToIgnoringCase("your name");
assertThat(option.getDefaultValue()).isNull();
assertThat(option.acceptValue()).isTrue();
assertThat(option.isMultiValued()).isFalse();
assertThat(option.isRequired()).isTrue();
}
@Test
public void retrievingArgumentsInATypeSafeWay() throws ParsingException {
cli = new CLI();
ArgumentSpec<Boolean> verbose = cli.option("-v").ofType(Boolean.class);
ArgumentSpec<Integer> size =
cli.option("--block-size").takingArgument("SIZE").ofType(int.class).defaultingTo(1024);
OperandSpec<File> input = cli.operand("input").ofType(File.class);
Args args = cli.parse("-v", "--block-size", "2048", "/path/to/input");
File inputFile = input.get(args);
assertEquals("/path/to/input", inputFile.getAbsolutePath());
boolean verboseFlag = verbose.get(args);
assertEquals(true, verboseFlag);
int blockSize = size.get(args);
assertEquals(2048, blockSize);
}
@Override
public <T> T getArgumentValue(String name) {
Argument arg = cli.getArgument(name);
if (arg == null) {
return null;
}
return getArgumentValue(arg.getIndex());
}
public static void main(String args[]) throws Exception {
CLI cli = new CLI();
CommandLine cl = cli.getCommandLine(args);
if (!cl.hasOption(CLI.O_ACTION)) {
cli.usage(new ParseException("missing required option " + CLI.O_ACTION), true);
}
String action = cl.getOptionValue(CLI.O_ACTION);
if ("dump".equals(action)) {
doDump(cl);
} else if ("check".equals(action)) {
doCheck(cl);
} else {
cli.usage(new ParseException("invalid option " + action), true);
}
}
/**
* Checks whether or not the user has passed a "help" option and is asking for help.
*
* @return {@code true} if the user command line has enabled a "Help" option, {@link false}
* otherwise.
*/
@Override
public boolean isAskingForHelp() {
for (Option option : cli.getOptions()) {
if (option.isHelp() && isSeenInCommandLine(option)) {
return true;
}
}
return false;
}
@Test
public void retrievingExtraArguments() throws ParsingException {
cli =
new CLI() {
{
operand("input");
}
};
Args args = cli.parse("input", "output", "encoding");
assertEquals(asList("output", "encoding"), args.others());
}
@Test
public void detectingAnUnrecognizedOption() throws Exception {
cli = new CLI();
try {
cli.parse("--whatever");
fail("Expected exception " + UnrecognizedOptionException.class.getName());
} catch (UnrecognizedOptionException expected) {
assertEquals("--whatever", expected.getOption());
assertThat(expected.getMessage(), containsString("whatever"));
}
}
@Override
public boolean isFlagEnabled(String name) {
Option option = cli.getOption(name);
if (option == null) {
throw new IllegalArgumentException("Cannot find the option '" + name + "'");
}
if (option.isFlag()) {
return optionsSeenInCommandLine.contains(option);
} else {
throw new IllegalStateException(
"Cannot retrieve the flag value on a non-flag option (" + name + ")");
}
}
@Override
@SuppressWarnings("unchecked")
public <T> T getOptionValue(String name) {
Option option = cli.getOption(name);
if (option == null) {
return null;
}
if (option instanceof TypedOption) {
return getValue((TypedOption<T>) option);
} else {
return (T) getRawValueForOption(option);
}
}
@Override
@SuppressWarnings("unchecked")
public <T> T getArgumentValue(int index) {
Argument arg = cli.getArgument(index);
if (arg == null) {
return null;
}
if (arg instanceof TypedArgument) {
return create(getRawValueForArgument(arg), (TypedArgument<T>) arg);
} else {
return (T) getRawValueForArgument(arg);
}
}
