@Override public String format(final Map<String, ? extends OptionDescriptor> options) { final Set<OptionDescriptor> opts = new LinkedHashSet<OptionDescriptor>( options.values()); lines.addAll(HELP_PREAMBLE); final int helpIndex = lines.size(); StringBuilder sb; for (final OptionDescriptor descriptor : opts) { if (descriptor.representsNonOptions()) continue; final Collection<String> names = descriptor.options(); sb = new StringBuilder().append(" ") .append(optionsToString(names)); if (descriptor.requiresArgument()) sb.append(" uri"); sb.append(": ").append(descriptor.description()); if (names.contains("help")) lines.add(helpIndex, sb.toString()); else lines.add(sb.toString()); } lines.addAll(HELP_POST); return JOINER.join(lines) + LINE_SEPARATOR; }
private String lineFor( OptionDescriptor descriptor ) { StringBuilder line = new StringBuilder(); for(String option:descriptor.options()) { line.append(option.length()>1?"--":"-"); line.append(option); line.append(" "); final int blankSize = line.length() + 2; if(descriptor.isRequired()) { line.append("REQUIRED: "); line.append(descriptor.description()); List<?> list = descriptor.defaultValues(); if(list!=null&&list.size()>0) { line.append("\n");
for (String str : d.options()) { if (!d.representsNonOptions()) { o.append("-"); if (d.acceptsArguments()) { o.append(" "); if (d.requiresArgument()) { o.append("<"); } else { o.append("["); o.append(d.argumentDescription()); if (d.requiresArgument()) { o.append(">"); } else { for (String l : rewrap(d.description())) { if (first) { first = false;
OptionDescriptor od = options.get(key); sb.append(" --"); sb.append(od.options().iterator().next()); if (!od.requiresArgument()) { sb.append(" <?>"); sb.append(od.description()); String type = od.argumentTypeIndicator(); if (type != null) { if (Integer.class.getCanonicalName().equals(type)) { List<?> values = od.defaultValues(); if (values != null && !values.isEmpty()) { sb.append(" (default: "); if (od.isRequired()) { sb.append(" (required)");
private String createOptionDisplay( OptionDescriptor descriptor ) { StringBuilder buffer = new StringBuilder( descriptor.isRequired() ? "* " : "" ); for ( Iterator<String> iter = descriptor.options().iterator(); iter.hasNext(); ) { String option = iter.next(); buffer.append( option.length() > 1 ? DOUBLE_HYPHEN : HYPHEN ); buffer.append( option ); if ( iter.hasNext() ) buffer.append( ", " ); } return buffer.toString(); }
/** * <p>Appends additional info about the given option to the given buffer.</p> * * <p>This implementation:</p> * <ul> * <li>calls {@link #extractTypeIndicator(OptionDescriptor)} for the descriptor</li> * <li>calls {@link joptsimple.OptionDescriptor#argumentDescription()} for the descriptor</li> * <li>if either of the above is present, calls * {@link #appendOptionHelp(StringBuilder, String, String, boolean)}</li> * </ul> * * @param buffer string buffer * @param descriptor a descriptor for a configured option of a parser */ protected void maybeAppendOptionInfo( StringBuilder buffer, OptionDescriptor descriptor ) { String indicator = extractTypeIndicator( descriptor ); String description = descriptor.argumentDescription(); if ( descriptor.acceptsArguments() || !isNullOrEmpty( description ) || descriptor.representsNonOptions() ) { appendOptionHelp( buffer, indicator, description, descriptor.requiresArgument() ); } }
private String createDescriptionDisplay( OptionDescriptor descriptor ) { List<?> defaultValues = descriptor.defaultValues(); if ( defaultValues.isEmpty() ) return descriptor.description(); String defaultValuesDisplay = createDefaultValuesDisplay( defaultValues ); return descriptor.description() + ' ' + surround( "default: " + defaultValuesDisplay, '(', ')' ); }
/** * <p>Decides whether or not to show a non-option arguments help.</p> * * <p>This implementation responds with {@code true} if the non-option descriptor has a non-{@code null}, * non-empty value for any of {@link OptionDescriptor#description()}, * {@link OptionDescriptor#argumentTypeIndicator()}, or {@link OptionDescriptor#argumentDescription()}.</p> * * @param nonOptionDescriptor non-option argument descriptor * @return {@code true} if non-options argument help should be shown */ protected boolean shouldShowNonOptionArgumentDisplay( OptionDescriptor nonOptionDescriptor ) { return !Strings.isNullOrEmpty( nonOptionDescriptor.description() ) || !Strings.isNullOrEmpty( nonOptionDescriptor.argumentTypeIndicator() ) || !Strings.isNullOrEmpty( nonOptionDescriptor.argumentDescription() ); }
private void addHelpLineFor( OptionDescriptor descriptor ) { if ( descriptor.acceptsArguments() ) { if ( descriptor.requiresArgument() ) addHelpLineWithArgument( descriptor, '<', '>' ); else addHelpLineWithArgument( descriptor, '[', ']' ); } else { addHelpLineFor( descriptor, "" ); } }
OptionHelpAdapter(OptionDescriptor descriptor) { this.options = new LinkedHashSet<>(); for (String option : descriptor.options()) { String prefix = (option.length() != 1) ? "--" : "-"; this.options.add(prefix + option); } if (this.options.contains("--cp")) { this.options.remove("--cp"); this.options.add("-cp"); } this.description = descriptor.description(); }
List<?> defaultValues = descriptor.defaultValues(); if ( defaultValues.isEmpty() ) return descriptor.description(); .map( v -> descriptor.argumentConverter() .map( c -> c.revert( v ) ) .orElse( String.valueOf( v ) ) ) .collect( toList() ); String defaultValuesDisplay = createDefaultValuesDisplay( stringifiedDefaults ); return ( descriptor.description() + ' ' + surround( message( "default.value.header" ) + ' ' + defaultValuesDisplay, '(', ')' )
@Override public String format(Map<String, ? extends OptionDescriptor> options) { Comparator<OptionDescriptor> comparator = Comparator.comparing( (optionDescriptor) -> optionDescriptor.options().iterator().next()); Set<OptionDescriptor> sorted = new TreeSet<>(comparator); sorted.addAll(options.values()); for (OptionDescriptor descriptor : sorted) { if (!descriptor.representsNonOptions()) { this.help.add(new OptionHelpAdapter(descriptor)); } } return ""; }
/** * <p>Appends help for the given non-option arguments descriptor to the given buffer.</p> * * <p>This implementation appends {@code " -- "} if the buffer has text in it and the non-option arguments * descriptor has a {@link OptionDescriptor#description()}; followed by the * {@link OptionDescriptor#description()}.</p> * * @param buffer string buffer * @param nonOptions non-option arguments descriptor */ protected void maybeAppendNonOptionsDescription( StringBuilder buffer, OptionDescriptor nonOptions ) { buffer.append( buffer.length() > 0 && !Strings.isNullOrEmpty( nonOptions.description() ) ? " -- " : "" ) .append( nonOptions.description() ); }
/** * Tells whether the given option descriptors contain a "required" option. * * @param options descriptors for the configured options of a parser * @return {@code true} if at least one of the options is "required" */ protected final boolean hasRequiredOption( Collection<? extends OptionDescriptor> options ) { for ( OptionDescriptor each : options ) { if ( each.isRequired() ) return true; } return false; }
private static String typeIndicator( OptionDescriptor descriptor ) { String indicator = descriptor.argumentTypeIndicator(); return indicator == null || String.class.getName().equals( indicator ) ? "" : shortNameOf( indicator ); } }
private void addHelpLineWithArgument( OptionDescriptor descriptor, char begin, char end ) { String argDescription = descriptor.argumentDescription(); String typeIndicator = typeIndicator( descriptor ); StringBuilder collector = new StringBuilder(); if ( typeIndicator.length() > 0 ) { collector.append( typeIndicator ); if ( argDescription.length() > 0 ) collector.append( ": " ).append( argDescription ); } else if ( argDescription.length() > 0 ) collector.append( argDescription ); String helpLine = collector.length() == 0 ? "" : ' ' + surround( collector.toString(), begin, end ); addHelpLineFor( descriptor, helpLine ); }
/** * Finds the non-option arguments descriptor in the given collection, removes it, and returns it. * * @param options descriptors for the configured options of a parser * @return the non-option arguments descriptor */ protected OptionDescriptor findAndRemoveNonOptionsSpec( Collection<? extends OptionDescriptor> options ) { for ( Iterator<? extends OptionDescriptor> it = options.iterator(); it.hasNext(); ) { OptionDescriptor next = it.next(); if ( next.representsNonOptions() ) { it.remove(); return next; } } throw new AssertionError( "no non-options argument spec" ); }
for (String str : d.options()) { if (!d.representsNonOptions()) { o.append("-"); if (d.acceptsArguments()) { o.append(" "); if (d.requiresArgument()) { o.append("<"); } else { o.append("["); o.append(d.argumentDescription()); if (d.requiresArgument()) { o.append(">"); } else { for (String l : rewrap(d.description())) { if (first) { first = false;
private String createOptionDisplay( OptionDescriptor descriptor ) { StringBuilder buffer = new StringBuilder( descriptor.isRequired() ? "* " : "" ); for ( Iterator<String> iter = descriptor.options().iterator(); iter.hasNext(); ) { String option = iter.next(); buffer.append( option.length() > 1 ? DOUBLE_HYPHEN : HYPHEN ); buffer.append( option ); if ( iter.hasNext() ) buffer.append( ", " ); } return buffer.toString(); }