private static List<OptionMetadata> mergeOptionSet(List<OptionMetadata> options) { ListMultimap<OptionMetadata, OptionMetadata> metadataIndex = ArrayListMultimap.create(); for (OptionMetadata option : options) { metadataIndex.put(option, option); } options = ImmutableList.copyOf(transform(metadataIndex.asMap().values(), new Function<Collection<OptionMetadata>, OptionMetadata>() { @Override public OptionMetadata apply(@Nullable Collection<OptionMetadata> options) { return new OptionMetadata(options); } })); Map<String, OptionMetadata> optionIndex = newHashMap(); for (OptionMetadata option : options) { for (String optionName : option.getOptions()) { if (optionIndex.containsKey(optionName)) { throw new IllegalArgumentException(String.format("Fields %s and %s have conflicting definitions of option %s", optionIndex.get(optionName).getAccessors().iterator().next(), option.getAccessors().iterator().next(), optionName)); } optionIndex.put(optionName, option); } } return options; }
public OptionMetadata(Iterable<OptionMetadata> options) { Preconditions.checkNotNull(options, "options is null"); Preconditions.checkArgument(!Iterables.isEmpty(options), "options is empty"); OptionMetadata option = options.iterator().next(); this.optionType = option.optionType; this.options = option.options; this.title = option.title; this.description = option.description; this.arity = option.arity; this.required = option.required; this.hidden = option.hidden; if (option.allowedValues != null) { this.allowedValues = ImmutableSet.copyOf(option.allowedValues); } else { this.allowedValues = null; } Set<Accessor> accessors = newHashSet(); for (OptionMetadata other : options) { Preconditions.checkArgument(option.equals(other), "Conflicting options definitions: %s, %s", option, other); accessors.addAll(other.getAccessors()); } this.accessors = ImmutableSet.copyOf(accessors); }
public static String toDescription(OptionMetadata option) { Set<String> options = option.getOptions(); StringBuilder stringBuilder = new StringBuilder(); final String argumentString; if (option.getArity() > 0) { argumentString = Joiner.on(" ").join(Lists.transform(ImmutableList.of(option.getTitle()), new Function<String, String>() { public String apply(@Nullable String argument) { return "<" + argument + ">"; } })); } else { argumentString = null; } Joiner.on(", ").appendTo(stringBuilder, transform(options, new Function<String, String>() { public String apply(@Nullable String option) { if (argumentString != null) { return option + " " + argumentString; } return option; } })); return stringBuilder.toString(); }
public static String toUsage(OptionMetadata option) Set<String> options = option.getOptions(); boolean required = option.isRequired(); StringBuilder stringBuilder = new StringBuilder(); if (!required) { if (option.getArity() > 0) { argumentString = Joiner.on(" ").join(transform(ImmutableList.of(option.getTitle()), new Function<String, String>() if (option.isMultiValued()) { stringBuilder.append("...");
if (option.getArity() == 0) { nextState = nextState.withOptionValue(option, Boolean.TRUE).popContext(); continue; if (option.getArity() == 1) { Object value = TypeConverter.newInstance().convert(option.getTitle(), option.getJavaType(), remainingToken); nextState = nextState.withOptionValue(option, value).popContext(); Object value = TypeConverter.newInstance().convert(option.getTitle(), option.getJavaType(), tokens.next()); nextState = nextState.withOptionValue(option, value).popContext(); throw new UnsupportedOperationException("Short options style can not be used with option " + option.getAllowedValues());
private ParseState parseLongGnuGetOpt(PeekingIterator<String> tokens, ParseState state, List<OptionMetadata> allowedOptions) { List<String> parts = ImmutableList.copyOf(Splitter.on('=').limit(2).split(tokens.peek())); if (parts.size() != 2) { return null; } OptionMetadata option = findOption(allowedOptions, parts.get(0)); if (option == null || option.getArity() != 1) { // TODO: this is not exactly correct. It should be an error condition return null; } // we have a match so consume the token tokens.next(); // update state state = state.pushContext(Context.OPTION).withOption(option); Object value = TypeConverter.newInstance().convert(option.getTitle(), option.getJavaType(), parts.get(1)); state = state.withOption(option).withOptionValue(option, value).popContext(); return state; }
private void validate(ParseState state) { CommandMetadata command = state.getCommand(); if (command == null) { List<String> unparsedInput = state.getUnparsedInput(); if (unparsedInput.isEmpty()) { throw new ParseCommandMissingException(); } else { throw new ParseCommandUnrecognizedException(unparsedInput); } } ArgumentsMetadata arguments = command.getArguments(); if (state.getParsedArguments().isEmpty() && arguments != null && arguments.isRequired()) { throw new ParseArgumentsMissingException(arguments.getTitle()); } if (!state.getUnparsedInput().isEmpty()) { throw new ParseArgumentsUnexpectedException(state.getUnparsedInput()); } if (state.getLocation() == Context.OPTION) { throw new ParseOptionMissingValueException(state.getCurrentOption().getTitle()); } for (OptionMetadata option : command.getAllOptions()) { if (option.isRequired() && !state.getParsedOptions().containsKey(option)) { throw new ParseOptionMissingException(option.getOptions().iterator().next()); } } }
if(option.isHidden()) descriptionPrinter.append(option.getDescription()).newline(); if (!option.isHidden() && option.getDescription() != null) { descriptionPrinter.append("With") .append(longest(option.getOptions())) .append("option,") .append(option.getDescription()) .newline() .newline();
if (option.isHidden()) { continue; descriptionPrinter.append(option.getDescription()).newline();
if (option.getArity() > 1 && !values.isEmpty()) { for (Accessor accessor : option.getAccessors()) { accessor.addValues(commandInstance, values);
public Set<String> apply(OptionMetadata input) { return input.getOptions(); } };
@Override public boolean apply(@Nullable OptionMetadata input) { return !input.isHidden(); } };
@Override public OptionMetadata apply(@Nullable Collection<OptionMetadata> options) { return new OptionMetadata(options); } }));
if (option.getArity() == 0) { state = state.withOptionValue(option, Boolean.TRUE).popContext(); else if (option.getArity() == 1) { if (tokens.hasNext()) { value = TypeConverter.newInstance().convert(option.getTitle(), option.getJavaType(), tokens.next()); state = state.withOptionValue(option, value).popContext(); while (count < option.getArity() && tokens.hasNext()) { values.add(TypeConverter.newInstance().convert(option.getTitle(), option.getJavaType(), tokens.next())); ++count; if (count == option.getArity()) { state = state.withOptionValue(option, values.build()).popContext();
if (option.isHidden()) descriptionPrinter.append(option.getDescription()).newline();
private OptionMetadata findOption(List<OptionMetadata> options, String param) { for (OptionMetadata optionMetadata : options) { if (optionMetadata.getOptions().contains(param)) { return optionMetadata; } } return null; }
public String apply(OptionMetadata option) { if (option.isHidden()) { return ""; } return toUsage(option); } }));
OptionMetadata optionMetadata = new OptionMetadata(optionType, options, name, description, arity, required, hidden, allowedValues, path); switch (optionType) { case GLOBAL:
@Override public int compare(OptionMetadata o1, OptionMetadata o2) { String option1 = o1.getOptions().iterator().next(); option1 = option1.replaceFirst("^-+", ""); String option2 = o2.getOptions().iterator().next(); option2 = option2.replaceFirst("^-+", ""); return ComparisonChain.start() .compare(option1.toLowerCase(), option2.toLowerCase()) .compare(option2, option1) // print lower case letters before upper case .compare(System.identityHashCode(o1), System.identityHashCode(o2)) .result(); } };
public String apply(OptionMetadata option) { if (option.isHidden()) { return ""; } return toUsage(option); } });