throw new IllegalArgumentException("The command cannot be defined, the @Name value is empty or null."); cli.setName(name.value()); cli.setSummary(summary.value()); cli.setDescription(desc.value()); cli.setHidden(true); cli.addOption(createOption(method)); cli.addArgument(createArgument(method));
@Test public void testThatDefaultValuesAreHandled() throws CLIException { cli.addArgument(new TypedArgument<String>().setIndex(0).setArgName("1").setType(String.class) .setDefaultValue("hello").setRequired(false)); evaluated = cli.parse(Collections.singletonList("a")); assertThat((String) evaluated.getArgumentValue(0)).isEqualTo("a"); evaluated = cli.parse(Collections.emptyList()); assertThat((String) evaluated.getArgumentValue(0)).isEqualTo("hello"); }
@Test public void testUsageComputationWhenUsingOnlyLongOption() { final CLI cli = CLI.create("test") .addOption(new Option().setLongName("file").setDescription("a file")); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()) .contains("test [--file <value>]") .contains(" --file <value> a file"); }
/** * Computes the usage of the given {@link CLI}. * * @param builder where the usage is going to be written * @param prefix a prefix to prepend to the usage line. It will be added between 'Usage: ' and the CLI name. * @param cli the cli */ public void usage(StringBuilder builder, String prefix, CLI cli) { computeUsageLine(builder, prefix, cli); if (cli.getSummary() != null && cli.getSummary().trim().length() > 0) { buildWrapped(builder, "\n" + cli.getSummary()); } if (cli.getDescription() != null && cli.getDescription().trim().length() > 0) { buildWrapped(builder, "\n" + cli.getDescription()); } builder.append("\n"); if (cli.getOptions().isEmpty() && cli.getArguments().isEmpty()) { // When we have neither options and arguments, just leave. return; } builder.append("Options and Arguments:\n"); computeOptionsAndArguments(builder, cli.getOptions(), cli.getArguments()); }
if (!command.isHidden()) { StringBuilder buf = new StringBuilder(); buf.append(lpad).append(" ").append(command.getName()); prefixList.add(buf); max = buf.length() > max ? buf.length() : max; if (command.isHidden()) { continue; buf.append(command.getSummary()); renderWrappedText(sb, width, nextLineTabStop, buf.toString());
public void computeUsageLine(StringBuilder buffer, String prefix, CLI cli) { // initialise the string buffer StringBuilder buff; if (prefix == null) { buff = new StringBuilder(getUsagePrefix()); } else { buff = new StringBuilder(getUsagePrefix()).append(prefix); if (!prefix.endsWith(" ")) { buff.append(" "); } } buff.append(cli.getName()).append(" "); if (getOptionComparator() != null) { Collections.sort(cli.getOptions(), getOptionComparator()); } // iterate over the options for (Option option : cli.getOptions()) { appendOption(buff, option); buff.append(" "); } // iterate over the arguments for (Argument arg : cli.getArguments()) { appendArgument(buff, arg, arg.isRequired()); buff.append(" "); } buildWrapped(buffer, buff.toString().indexOf(' ') + 1, buff.toString()); }
@Test public void testUsageComputationWhenUsingRequiredOptionAndArgument() { final CLI cli = CLI.create("test") .addOption(new Option().setLongName("file").setShortName("f").setDescription("a file").setRequired(true)) .addArgument(new Argument().setArgName("foo").setDescription("foo").setRequired(true)); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()) .contains("test -f <value> foo") .contains(" -f,--file <value> a file") .contains("<foo> foo"); }
@Test public void testWithOneShortOptionUsingSpace() throws CLIException { Option[] options = new Option[]{ new Option().setShortName("f").setLongName("file").setSingleValued(true) }; cli.addOptions(Arrays.asList(options)); CommandLine evaluated = cli.parse(Arrays.asList("-f", "hello.txt")); assertThat(evaluated.cli().getOptions()).hasSize(1); assertThat((String) evaluated.getOptionValue("file")).isEqualTo("hello.txt"); assertThat(evaluated.getOptionValues("f")).containsExactly("hello.txt"); }
@Test(expected = MissingValueException.class) public void testCommandLineValidationWhenInvalid() { final CLI cli = CLI.create("test") .addArgument(new Argument().setArgName("foo").setRequired(true)); cli.parse(Collections.<String>emptyList()); }
static CommandLine cli(String[] args) { CLI cli = CLI.create("java -jar <mqtt-broker>-fat.jar") .setSummary("A vert.x MQTT Broker") .addOption(new Option() .setLongName("conf") .setShortName("c") .setRequired(true) .addOption(new Option() .setLongName("hazelcast-conf") .setShortName("hc") .addOption(new Option() .setLongName("hazelcast-host") .setShortName("hh") .addOption(new Option() .setLongName("hazelcast-members") .setShortName("hm") try { List<String> userCommandLineArguments = Arrays.asList(args); commandLine = cli.parse(userCommandLineArguments); } catch(CLIException e) { cli.usage(builder); System.out.println(builder.toString());
@Test public void testWithOneLongOption() throws CLIException { Option[] options = new Option[]{ new Option().setShortName("f").setLongName("file").setSingleValued(true) }; cli.addOptions(Arrays.asList(options)); CommandLine evaluated = cli.parse(Collections.singletonList("--file=hello.txt")); assertThat(evaluated.cli().getOptions()).hasSize(1); assertThat((String) evaluated.getOptionValue("file")).isEqualTo("hello.txt"); assertThat(evaluated.getOptionValues("f")).containsExactly("hello.txt"); StringBuilder usage = new StringBuilder(); cli.usage(usage); assertThat(usage.toString()).startsWith("Usage: test [-f <value>]"); assertThat(usage.toString()).contains("-f,--file <value>"); }
@Test public void testNegativeNumbers() throws CLIException { CLI cli = new DefaultCLI().setName("test"); Option[] options = new Option[]{ new TypedOption<Double>().setLongName("num").setSingleValued(true) .setType(Double.class) }; cli.addOptions(Arrays.asList(options)); CommandLine evaluated = cli.parse(Arrays.asList("--num", "-1.5")); assertThat(evaluated.cli().getOptions()).hasSize(1); assertThat(cli.getArguments()).isEmpty(); assertThat((double) evaluated.getOptionValue("num")).isEqualTo(-1.5d); evaluated = cli.parse(Collections.singletonList("--num=-1.5")); assertThat(evaluated.cli().getOptions()).hasSize(1); assertThat(cli.getArguments()).isEmpty(); assertThat((double) evaluated.getOptionValue("num")).isEqualTo(-1.5d); }
@Test public void testWithDashD() throws CLIException { CLI cli = new DefaultCLI().setName("test"); Option[] options = new Option[]{ new TypedOption<String>().setShortName("D").setLongName("systemProperty") .setMultiValued(true).setType(String.class), new TypedOption<Boolean>().setShortName("F").setLongName("flag") .setFlag(true) .setType(Boolean.class) }; cli.addOptions(Arrays.asList(options)); CommandLine evaluated = cli.parse(Arrays.asList("-Dx=y", "-F")); assertThat(evaluated.cli().getOptions()).hasSize(2); assertThat(evaluated.getRawValueForOption(evaluated.cli().getOption("systemProperty"))) .isEqualTo("x=y"); assertThat((boolean) evaluated.getOptionValue("flag")).isTrue(); }
@Test public void testFlag() { final CLI cli = CLI.create("test") .addOption(new Option().setShortName("f").setFlag(true)) .addOption(new Option().setShortName("x")); final CommandLine evaluated = cli.parse(Arrays.asList("-f", "-x", "foo")); assertThat(evaluated.isFlagEnabled("f")).isTrue(); assertThat((String) evaluated.getOptionValue("x")).isEqualToIgnoringCase("foo"); }
@Test public void testThatArgumentsAreOrdered() throws CLIException { cli.addArgument(new TypedArgument<String>().setIndex(1).setArgName("1").setType(String.class)); cli.addArgument(new TypedArgument<String>().setIndex(0).setArgName("2").setType(String.class)); cli.addArgument(new TypedArgument<String>().setIndex(2).setArgName("3").setType(String.class)); assertThat(cli.getArguments()).hasSize(3); evaluated = cli.parse(Arrays.asList("a", "b", "c")); Iterator<Argument> iterator = cli.getArguments().iterator(); assertThat(iterator.next().getArgName()).isEqualTo("2"); assertThat(iterator.next().getArgName()).isEqualTo("1"); assertThat(iterator.next().getArgName()).isEqualTo("3"); assertThat((String) evaluated.getArgumentValue("2")).isEqualTo("a"); assertThat((String) evaluated.getArgumentValue("1")).isEqualTo("b"); assertThat((String) evaluated.getArgumentValue("3")).isEqualTo("c"); }
@Test public void testUsageComputationWhenUsingNotRequiredArgument() { final CLI cli = CLI.create("test") .addArgument(new Argument().setArgName("foo").setRequired(false)); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()) .contains("test [foo]"); }
@Test public void testWithArgumentReceivingMultipleValues() { CLI cli = new DefaultCLI().setName("test"); cli.addArgument(new Argument().setIndex(0).setArgName("arg").setDescription("argument1")); cli.addArgument(new Argument().setIndex(1).setMultiValued(true).setArgName("m").setDescription("multiple arg")); CommandLine cl = cli.parse(Arrays.asList("a", "b", "c")); assertThat((String) cl.getArgumentValue(0)).isEqualTo("a"); assertThat(cl.getArgumentValues(1)).containsExactly("b", "c"); assertThat((String) cl.getArgumentValue(1)).isEqualTo("b"); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()).contains("test arg m..."); }
CLI cli = CLI.create("wget").setSummary("Wget implemented with Vert.x HTTP client"). addArgument(new Argument().setIndex(0).setArgName("http-url").setDescription("the HTTP uri to get"));
public static CLI define() { return new DefaultCLI().setName("bye").addOption(new TypedOption<String>() .setType(String.class) .setRequired(true) .setShortName("n") .setSingleValued(true)) .setSummary("A command saying goodbye."); }
@Test public void testUsageWhenNoArgsAndOptions() { final CLI cli = CLI.create("test").setDescription("A simple test command."); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()) .contains("test") .doesNotContain("Options").doesNotContain("Arguments"); }