argumentType ) {
return withValuesConvertedBy( findConverter( argumentType ) );
}
/**
* Specifies a converter to use to translate arguments of this spec's option into Java objects. This is useful
* when converting to types that do not have the requisite factory method or constructor for
* {@link #ofType(Class)}.
*
* Invoking this method will trump any previous calls to this method or to {@link #ofType(Class)}.
*
* @param represents the runtime class of the desired option argument type
* @param aConverter the converter to use
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws NullPointerException if the converter is {@code null}
*/
@SuppressWarnings( "unchecked" )
public final ArgumentAcceptingOptionSpec withValuesConvertedBy( ValueConverter aConverter ) {
if ( aConverter == null )
throw new NullPointerException( "illegal null converter" );
converter = (ValueConverter) aConverter;
return (ArgumentAcceptingOptionSpec) this;
}
/**
* Specifies a description for the argument of the option that this spec represents. This description is used
* when generating help information about the parser.
*
* @param description describes the nature of the argument of this spec's option
* @return self, so that the caller can add clauses to the fluent interface sentence
*/
public final ArgumentAcceptingOptionSpec describedAs( String description ) {
argumentDescription = description;
return this;
}
/**
* Specifies a value separator for the argument of the option that this spec represents. This allows a single
* option argument to represent multiple values for the option. For example:
*
*
*
* parser.accepts( "z" ).withRequiredArg()
* .withValuesSeparatedBy( ',' );
* OptionSet options = parser.parse( new String[] { "-z", "foo,bar,baz", "-z",
* "fizz", "-z", "buzz" } );
*
*
*
* Then options.valuesOf( "z" ) would yield the list {@code [foo, bar, baz, fizz, buzz]}.
*
* You cannot use Unicode U+0000 as the separator.
*
* @param separator a character separator
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws IllegalArgumentException if the separator is Unicode U+0000
*/
public final ArgumentAcceptingOptionSpec withValuesSeparatedBy( char separator ) {
if ( separator == NIL_VALUE_SEPARATOR )
throw new IllegalArgumentException( "cannot use U+0000 as separator" );
valueSeparator = String.valueOf( separator );
return this;
}
/**
* Specifies a value separator for the argument of the option that this spec represents. This allows a single
* option argument to represent multiple values for the option. For example:
*
*
*
* parser.accepts( "z" ).withRequiredArg()
* .withValuesSeparatedBy( ":::" );
* OptionSet options = parser.parse( new String[] { "-z", "foo:::bar:::baz", "-z",
* "fizz", "-z", "buzz" } );
*
*
*
* Then options.valuesOf( "z" ) would yield the list {@code [foo, bar, baz, fizz, buzz]}.
*
* You cannot use Unicode U+0000 in the separator.
*
* @param separator a string separator
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws IllegalArgumentException if the separator contains Unicode U+0000
*/
public final ArgumentAcceptingOptionSpec withValuesSeparatedBy( String separator ) {
if ( separator.indexOf( NIL_VALUE_SEPARATOR ) != -1 )
throw new IllegalArgumentException( "cannot use U+0000 in separator" );
valueSeparator = separator;
return this;
}
/**
* Specifies a set of default values for the argument of the option that this spec represents.
*
* @param value the first in the set of default argument values for this spec's option
* @param values the (optional) remainder of the set of default argument values for this spec's option
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws NullPointerException if {@code value}, {@code values}, or any elements of {@code values} are
* {@code null}
*/
@SafeVarargs
public final ArgumentAcceptingOptionSpec defaultsTo( V value, V... values ) {
addDefaultValue( value );
defaultsTo( values );
return this;
}
/**
* Specifies a set of default values for the argument of the option that this spec represents.
*
* @param values the set of default argument values for this spec's option
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws NullPointerException if {@code values} or any elements of {@code values} are {@code null}
*/
public ArgumentAcceptingOptionSpec defaultsTo( V[] values ) {
for ( V each : values )
addDefaultValue( each );
return this;
}
/**
* Marks this option as required. An {@link OptionException} will be thrown when
* {@link OptionParser#parse(java.lang.String...)} is called, if an option is marked as required and not specified
* on the command line.
*
* @return self, so that the caller can add clauses to the fluent interface sentence
*/
public ArgumentAcceptingOptionSpec required() {
optionRequired = true;
return this;
}
public boolean isRequired() {
return optionRequired;
}
private void addDefaultValue( V value ) {
requireNonNull( value );
defaultValues.add( value );
}
@Override
final void handleOption( OptionParser parser, ArgumentList arguments, OptionSet detectedOptions,
String detectedArgument ) {
if ( detectedArgument == null )
detectOptionArgument( parser, arguments, detectedOptions );
else
addArguments( detectedOptions, detectedArgument );
}
protected void addArguments( OptionSet detectedOptions, String detectedArgument ) {
StringTokenizer lexer = new StringTokenizer( detectedArgument, valueSeparator );
if ( !lexer.hasMoreTokens() )
detectedOptions.addWithArgument( this, detectedArgument );
else {
while ( lexer.hasMoreTokens() )
detectedOptions.addWithArgument( this, lexer.nextToken() );
}
}
protected abstract void detectOptionArgument( OptionParser parser, ArgumentList arguments,
OptionSet detectedOptions );
@Override
protected final V convert( String argument ) {
return convertWith( converter, argument );
}
protected boolean canConvertArgument( String argument ) {
StringTokenizer lexer = new StringTokenizer( argument, valueSeparator );
try {
while ( lexer.hasMoreTokens() )
convert( lexer.nextToken() );
return true;
} catch ( OptionException ignored ) {
return false;
}
}
protected boolean isArgumentOfNumberType() {
return converter != null && Number.class.isAssignableFrom( converter.valueType() );
}
public boolean acceptsArguments() {
return true;
}
public boolean requiresArgument() {
return argumentRequired;
}
public String argumentDescription() {
return argumentDescription;
}
public String argumentTypeIndicator() {
return argumentTypeIndicatorFrom( converter );
}
public List defaultValues() {
return unmodifiableList( defaultValues );
}
@Override
public boolean equals( Object that ) {
if ( !super.equals( that ) )
return false;
ArgumentAcceptingOptionSpec other = (ArgumentAcceptingOptionSpec) that;
return requiresArgument() == other.requiresArgument();
}
@Override
public int hashCode() {
return super.hashCode() ^ ( argumentRequired ? 0 : 1 );
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/ArgumentList.java 0000664 0000000 0000000 00000003561 13131706656 0026344 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import static joptsimple.ParserRules.*;
/**
* Wrapper for an array of command line arguments.
*
* @author Paul Holser
*/
class ArgumentList {
private final String[] arguments;
private int currentIndex;
ArgumentList( String... arguments ) {
this.arguments = arguments.clone();
}
boolean hasMore() {
return currentIndex < arguments.length;
}
String next() {
return arguments[ currentIndex++ ];
}
String peek() {
return arguments[ currentIndex ];
}
void treatNextAsLongOption() {
if ( HYPHEN_CHAR != arguments[ currentIndex ].charAt( 0 ) )
arguments[ currentIndex ] = DOUBLE_HYPHEN + arguments[ currentIndex ];
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/BuiltinHelpFormatter.java 0000664 0000000 0000000 00000055160 13131706656 0030033 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.*;
import joptsimple.internal.Messages;
import joptsimple.internal.Rows;
import joptsimple.internal.Strings;
import static joptsimple.ParserRules.*;
import static joptsimple.internal.Classes.*;
import static joptsimple.internal.Strings.*;
/**
* A help formatter that allows configuration of overall row width and column separator width.
*
* The formatter produces output in two sections: one for the options, and one for non-option arguments.
*
* The options section has two columns: the left column for the options, and the right column for their
* descriptions. The formatter will allow as much space as possible for the descriptions, by minimizing the option
* column's width, no greater than slightly less than half the overall desired width.
*
* The non-option arguments section is one column, occupying as much width as it can.
*
* Subclasses are free to override bits of this implementation as they see fit. Inspect the code
* carefully to understand the flow of control that this implementation guarantees.
*
* @author Paul Holser
*/
public class BuiltinHelpFormatter implements HelpFormatter {
private final Rows nonOptionRows;
private final Rows optionRows;
/**
* Makes a formatter with a pre-configured overall row width and column separator width.
*/
BuiltinHelpFormatter() {
this( 80, 2 );
}
/**
* Makes a formatter with a given overall row width and column separator width.
*
* @param desiredOverallWidth how many characters wide to make the overall help display
* @param desiredColumnSeparatorWidth how many characters wide to make the separation between option column and
* description column
*/
public BuiltinHelpFormatter( int desiredOverallWidth, int desiredColumnSeparatorWidth ) {
nonOptionRows = new Rows( desiredOverallWidth * 2, 0 );
optionRows = new Rows( desiredOverallWidth, desiredColumnSeparatorWidth );
}
/**
* {@inheritDoc}
*
* This implementation:
*
* - Sorts the given descriptors by their first elements of {@link OptionDescriptor#options()}
* - Passes the resulting sorted set to {@link #addRows(java.util.Collection)}
* - Returns the result of {@link #formattedHelpOutput()}
*
*/
public String format( Map options ) {
optionRows.reset();
nonOptionRows.reset();
Comparator comparator =
new Comparator() {
public int compare( OptionDescriptor first, OptionDescriptor second ) {
return first.options().iterator().next().compareTo( second.options().iterator().next() );
}
};
Set sorted = new TreeSet<>( comparator );
sorted.addAll( options.values() );
addRows( sorted );
return formattedHelpOutput();
}
/**
* Adds a row of option help output in the left column, with empty space in the right column.
*
* @param single text to put in the left column
*/
protected void addOptionRow( String single ) {
addOptionRow( single, "" );
}
/**
* Adds a row of option help output in the left and right columns.
*
* @param left text to put in the left column
* @param right text to put in the right column
*/
protected void addOptionRow( String left, String right ) {
optionRows.add( left, right );
}
/**
* Adds a single row of non-option argument help.
*
* @param single single row of non-option argument help text
*/
protected void addNonOptionRow( String single ) {
nonOptionRows.add( single, "" );
}
/**
* Resizes the columns of all the rows to be no wider than the widest element in that column.
*/
protected void fitRowsToWidth() {
nonOptionRows.fitToWidth();
optionRows.fitToWidth();
}
/**
* Produces non-option argument help.
*
* @return non-option argument help
*/
protected String nonOptionOutput() {
return nonOptionRows.render();
}
/**
* Produces help for options and their descriptions.
*
* @return option help
*/
protected String optionOutput() {
return optionRows.render();
}
/**
* Produces help output for an entire set of options and non-option arguments.
*
* This implementation concatenates:
*
* - the result of {@link #nonOptionOutput()}
* - if there is non-option output, a line separator
* - the result of {@link #optionOutput()}
*
*
* @return help output for entire set of options and non-option arguments
*/
protected String formattedHelpOutput() {
StringBuilder formatted = new StringBuilder();
String nonOptionDisplay = nonOptionOutput();
if ( !Strings.isNullOrEmpty( nonOptionDisplay ) )
formatted.append( nonOptionDisplay ).append( LINE_SEPARATOR );
formatted.append( optionOutput() );
return formatted.toString();
}
/**
* Adds rows of help output for the given options.
*
* This implementation:
*
* - Calls {@link #addNonOptionsDescription(java.util.Collection)} with the options as the argument
* - If there are no options, calls {@link #addOptionRow(String)} with an argument that indicates
* that no options are specified.
* - Otherwise, calls {@link #addHeaders(java.util.Collection)} with the options as the argument,
* followed by {@link #addOptions(java.util.Collection)} with the options as the argument.
* - Calls {@link #fitRowsToWidth()}.
*
*
* @param options descriptors for the configured options of a parser
*/
protected void addRows( Collection options ) {
addNonOptionsDescription( options );
if ( options.isEmpty() )
addOptionRow( message( "no.options.specified" ) );
else {
addHeaders( options );
addOptions( options );
}
fitRowsToWidth();
}
/**
* Adds non-option arguments descriptions to the help output.
*
* This implementation:
*
* - {@linkplain #findAndRemoveNonOptionsSpec(java.util.Collection) Finds and removes the non-option
* arguments descriptor}
* - {@linkplain #shouldShowNonOptionArgumentDisplay(OptionDescriptor) Decides whether there is
* anything to show for non-option arguments}
* - If there is, {@linkplain #addNonOptionRow(String) adds a header row} and
* {@linkplain #addNonOptionRow(String) adds a}
* {@linkplain #createNonOptionArgumentsDisplay(OptionDescriptor) non-option arguments description}
*
*
* @param options descriptors for the configured options of a parser
*/
protected void addNonOptionsDescription( Collection options ) {
OptionDescriptor nonOptions = findAndRemoveNonOptionsSpec( options );
if ( shouldShowNonOptionArgumentDisplay( nonOptions ) ) {
addNonOptionRow( message( "non.option.arguments.header" ) );
addNonOptionRow( createNonOptionArgumentsDisplay( nonOptions ) );
}
}
/**
* Decides whether or not to show a non-option arguments help.
*
* 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()}.
*
* @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() );
}
/**
* Creates a non-options argument help string.
*
* This implementation creates an empty string buffer and calls
* {@link #maybeAppendOptionInfo(StringBuilder, OptionDescriptor)}
* and {@link #maybeAppendNonOptionsDescription(StringBuilder, OptionDescriptor)}, passing them the
* buffer and the non-option arguments descriptor.
*
* @param nonOptionDescriptor non-option argument descriptor
* @return help string for non-options
*/
protected String createNonOptionArgumentsDisplay( OptionDescriptor nonOptionDescriptor ) {
StringBuilder buffer = new StringBuilder();
maybeAppendOptionInfo( buffer, nonOptionDescriptor );
maybeAppendNonOptionsDescription( buffer, nonOptionDescriptor );
return buffer.toString();
}
/**
* Appends help for the given non-option arguments descriptor to the given buffer.
*
* 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()}.
*
* @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() );
}
/**
* 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 options ) {
for ( Iterator it = options.iterator(); it.hasNext(); ) {
OptionDescriptor next = it.next();
if ( next.representsNonOptions() ) {
it.remove();
return next;
}
}
throw new AssertionError( "no non-options argument spec" );
}
/**
* Adds help row headers for option help columns.
*
* This implementation uses the headers {@code "Option"} and {@code "Description"}. If the options contain
* a "required" option, the {@code "Option"} header looks like {@code "Option (* = required)}. Both headers
* are "underlined" using {@code "-"}.
*
* @param options descriptors for the configured options of a parser
*/
protected void addHeaders( Collection options ) {
if ( hasRequiredOption( options ) ) {
addOptionRow( message( "option.header.with.required.indicator" ), message( "description.header" ) );
addOptionRow( message( "option.divider.with.required.indicator" ), message( "description.divider" ) );
} else {
addOptionRow( message( "option.header" ), message( "description.header" ) );
addOptionRow( message( "option.divider" ), message( "description.divider" ) );
}
}
/**
* 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 options ) {
for ( OptionDescriptor each : options ) {
if ( each.isRequired() )
return true;
}
return false;
}
/**
* Adds help rows for the given options.
*
* This implementation loops over the given options, and for each, calls {@link #addOptionRow(String, String)}
* using the results of {@link #createOptionDisplay(OptionDescriptor)} and
* {@link #createDescriptionDisplay(OptionDescriptor)}, respectively, as arguments.
*
* @param options descriptors for the configured options of a parser
*/
protected void addOptions( Collection options ) {
for ( OptionDescriptor each : options ) {
if ( !each.representsNonOptions() )
addOptionRow( createOptionDisplay( each ), createDescriptionDisplay( each ) );
}
}
/**
* Creates a string for how the given option descriptor is to be represented in help.
*
* This implementation gives a string consisting of the concatenation of:
*
* - {@code "* "} for "required" options, otherwise {@code ""}
* - For each of the {@link OptionDescriptor#options()} of the descriptor, separated by {@code ", "}:
*
* - {@link #optionLeader(String)} of the option
* - the option
*
*
* - the result of {@link #maybeAppendOptionInfo(StringBuilder, OptionDescriptor)}
*
*
* @param descriptor a descriptor for a configured option of a parser
* @return help string
*/
protected String createOptionDisplay( OptionDescriptor descriptor ) {
StringBuilder buffer = new StringBuilder( descriptor.isRequired() ? "* " : "" );
for ( Iterator i = descriptor.options().iterator(); i.hasNext(); ) {
String option = i.next();
buffer.append( optionLeader( option ) );
buffer.append( option );
if ( i.hasNext() )
buffer.append( ", " );
}
maybeAppendOptionInfo( buffer, descriptor );
return buffer.toString();
}
/**
* Gives a string that represents the given option's "option leader" in help.
*
* This implementation answers with {@code "--"} for options of length greater than one; otherwise answers
* with {@code "-"}.
*
* @param option a string option
* @return an "option leader" string
*/
protected String optionLeader( String option ) {
return option.length() > 1 ? DOUBLE_HYPHEN : HYPHEN;
}
/**
* Appends additional info about the given option to the given buffer.
*
* This implementation:
*
* - calls {@link #extractTypeIndicator(OptionDescriptor)} for the descriptor
* - calls {@link joptsimple.OptionDescriptor#argumentDescription()} for the descriptor
* - if either of the above is present, calls
* {@link #appendOptionHelp(StringBuilder, String, String, boolean)}
*
*
* @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() );
}
}
/**
* Gives an indicator of the type of arguments of the option described by the given descriptor,
* for use in help.
*
* This implementation asks for the {@link OptionDescriptor#argumentTypeIndicator()} of the given
* descriptor, and if it is present and not {@code "java.lang.String"}, parses it as a fully qualified
* class name and returns the base name of that class; otherwise returns {@code "String"}.
*
* @param descriptor a descriptor for a configured option of a parser
* @return type indicator text
*/
protected String extractTypeIndicator( OptionDescriptor descriptor ) {
String indicator = descriptor.argumentTypeIndicator();
if ( !isNullOrEmpty( indicator ) && !String.class.getName().equals( indicator ) )
return shortNameOf( indicator );
return "String";
}
/**
* Appends info about an option's argument to the given buffer.
*
* This implementation calls {@link #appendTypeIndicator(StringBuilder, String, String, char, char)} with
* the surrounding characters {@code '<'} and {@code '>'} for options with {@code required} arguments, and
* with the surrounding characters {@code '['} and {@code ']'} for options with optional arguments.
*
* @param buffer string buffer
* @param typeIndicator type indicator
* @param description type description
* @param required indicator of "required"-ness of the argument of the option
*/
protected void appendOptionHelp( StringBuilder buffer, String typeIndicator, String description,
boolean required ) {
if ( required )
appendTypeIndicator( buffer, typeIndicator, description, '<', '>' );
else
appendTypeIndicator( buffer, typeIndicator, description, '[', ']' );
}
/**
* Appends a type indicator for an option's argument to the given buffer.
*
* This implementation appends, in order:
*
* - {@code ' '}
* - {@code start}
* - the type indicator, if not {@code null}
* - if the description is present, then {@code ": "} plus the description if the type indicator is
* present; otherwise the description only
* - {@code end}
*
*
* @param buffer string buffer
* @param typeIndicator type indicator
* @param description type description
* @param start starting character
* @param end ending character
*/
protected void appendTypeIndicator( StringBuilder buffer, String typeIndicator, String description,
char start, char end ) {
buffer.append( ' ' ).append( start );
if ( typeIndicator != null )
buffer.append( typeIndicator );
if ( !Strings.isNullOrEmpty( description ) ) {
if ( typeIndicator != null )
buffer.append( ": " );
buffer.append( description );
}
buffer.append( end );
}
/**
* Gives a string representing a description of the option with the given descriptor.
*
* This implementation:
*
* - Asks for the descriptor's {@link OptionDescriptor#defaultValues()}
* - If they're not present, answers the descriptor's {@link OptionDescriptor#description()}.
* - If they are present, concatenates and returns:
*
* - the descriptor's {@link OptionDescriptor#description()}
* - {@code ' '}
* - {@code "default: "} plus the result of {@link #createDefaultValuesDisplay(java.util.List)},
* surrounded by parentheses
*
*
*
*
* @param descriptor a descriptor for a configured option of a parser
* @return display text for the option's description
*/
protected String createDescriptionDisplay( OptionDescriptor descriptor ) {
List defaultValues = descriptor.defaultValues();
if ( defaultValues.isEmpty() )
return descriptor.description();
String defaultValuesDisplay = createDefaultValuesDisplay( defaultValues );
return ( descriptor.description()
+ ' '
+ surround( message( "default.value.header" ) + ' ' + defaultValuesDisplay, '(', ')' )
).trim();
}
/**
* Gives a display string for the default values of an option's argument.
*
* This implementation gives the {@link Object#toString()} of the first value if there is only one value,
* otherwise gives the {@link Object#toString()} of the whole list.
*
* @param defaultValues some default values for a given option's argument
* @return a display string for those default values
*/
protected String createDefaultValuesDisplay( List defaultValues ) {
return defaultValues.size() == 1 ? defaultValues.get( 0 ).toString() : defaultValues.toString();
}
/**
* Looks up and gives a resource bundle message.
*
* This implementation looks in the bundle {@code "joptsimple.HelpFormatterMessages"} in the default
* locale, using a key that is the concatenation of this class's fully qualified name, {@code '.'},
* and the given key suffix, formats the corresponding value using the given arguments, and returns
* the result.
*
* @param keySuffix suffix to use when looking up the bundle message
* @param args arguments to fill in the message template with
* @return a formatted localized message
*/
protected String message( String keySuffix, Object... args ) {
return Messages.message(
Locale.getDefault(),
"joptsimple.HelpFormatterMessages",
BuiltinHelpFormatter.class,
keySuffix,
args );
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/HelpFormatter.java 0000664 0000000 0000000 00000003341 13131706656 0026476 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.Map;
/**
* Represents objects charged with taking a set of option descriptions and producing some help text from them.
*
* @author Paul Holser
*/
public interface HelpFormatter {
/**
* Produces help text, given a set of option descriptors.
*
* @param options descriptors for the configured options of a parser
* @return text to be used as help
* @see OptionParser#printHelpOn(java.io.Writer)
* @see OptionParser#formatHelpWith(HelpFormatter)
*/
String format( Map options );
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/IllegalOptionSpecificationException.java 0000664 0000000 0000000 00000003227 13131706656 0033047 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import static java.util.Collections.*;
/**
* Thrown when the option parser is asked to recognize an option with illegal characters in it.
*
* @author Paul Holser
*/
class IllegalOptionSpecificationException extends OptionException {
private static final long serialVersionUID = -1L;
IllegalOptionSpecificationException( String option ) {
super( singletonList( option ) );
}
@Override
Object[] messageArguments() {
return new Object[] { singleOptionString() };
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/MissingRequiredOptionsException.java 0000664 0000000 0000000 00000003235 13131706656 0032271 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
/**
* Thrown when options marked as required are not specified on the command line.
*
* @author Emils Solmanis
*/
class MissingRequiredOptionsException extends OptionException {
private static final long serialVersionUID = -1L;
protected MissingRequiredOptionsException( List> missingRequiredOptions ) {
super( missingRequiredOptions );
}
@Override
Object[] messageArguments() {
return new Object[] { multipleOptionString() };
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/MultipleArgumentsForOptionException.java 0000664 0000000 0000000 00000003251 13131706656 0033122 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import static java.util.Collections.*;
/**
* Thrown when asking an {@link OptionSet} for a single argument of an option when many have been specified.
*
* @author Paul Holser
*/
class MultipleArgumentsForOptionException extends OptionException {
private static final long serialVersionUID = -1L;
MultipleArgumentsForOptionException( OptionSpec options ) {
super( singleton( options ) );
}
@Override
Object[] messageArguments() {
return new Object[] { singleOptionString() };
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/NoArgumentOptionSpec.java 0000664 0000000 0000000 00000004405 13131706656 0030007 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
import static java.util.Collections.*;
/**
* A specification for an option that does not accept arguments.
*
* @author Paul Holser
*/
class NoArgumentOptionSpec extends AbstractOptionSpec {
NoArgumentOptionSpec( String option ) {
this( singletonList( option ), "" );
}
NoArgumentOptionSpec( List options, String description ) {
super( options, description );
}
@Override
void handleOption( OptionParser parser, ArgumentList arguments, OptionSet detectedOptions,
String detectedArgument ) {
detectedOptions.add( this );
}
public boolean acceptsArguments() {
return false;
}
public boolean requiresArgument() {
return false;
}
public boolean isRequired() {
return false;
}
public String argumentDescription() {
return "";
}
public String argumentTypeIndicator() {
return "";
}
@Override
protected Void convert( String argument ) {
return null;
}
public List defaultValues() {
return emptyList();
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/NonOptionArgumentSpec.java 0000664 0000000 0000000 00000014323 13131706656 0030165 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static joptsimple.internal.Reflection.*;
/**
* Specification of a command line's non-option arguments.
*
* Instances are returned from {@link OptionParser} methods to allow the formation of parser directives as
* sentences in a "fluent interface" language. For example:
*
*
*
* OptionParser parser = new OptionParser();
* parser.nonOptions( "files to be processed" ).ofType( File.class );
*
*
*
* If no methods are invoked on an instance of this class, then that instance's option will treat the non-option
* arguments as {@link String}s.
*
* @param represents the type of the non-option arguments
* @author Paul Holser
*/
public class NonOptionArgumentSpec extends AbstractOptionSpec {
static final String NAME = "[arguments]";
private ValueConverter converter;
private String argumentDescription = "";
NonOptionArgumentSpec() {
this( "" );
}
NonOptionArgumentSpec( String description ) {
super( asList( NAME ), description );
}
/**
* Specifies a type to which the non-option arguments are to be converted.
*
* JOpt Simple accepts types that have either:
*
*
* - a public static method called {@code valueOf} which accepts a single argument of type {@link String}
* and whose return type is the same as the class on which the method is declared. The {@code java.lang}
* primitive wrapper classes have such methods.
*
* - a public constructor which accepts a single argument of type {@link String}.
*
*
* This class converts arguments using those methods in that order; that is, {@code valueOf} would be invoked
* before a one-{@link String}-arg constructor would.
*
* Invoking this method will trump any previous calls to this method or to
* {@link #withValuesConvertedBy(ValueConverter)}.
*
* @param represents the runtime class of the desired option argument type
* @param argumentType desired type of arguments to this spec's option
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws NullPointerException if the type is {@code null}
* @throws IllegalArgumentException if the type does not have the standard conversion methods
*/
@SuppressWarnings( "unchecked" )
public NonOptionArgumentSpec ofType( Class argumentType ) {
converter = (ValueConverter) findConverter( argumentType );
return (NonOptionArgumentSpec) this;
}
/**
* Specifies a converter to use to translate non-option arguments into Java objects. This is useful
* when converting to types that do not have the requisite factory method or constructor for
* {@link #ofType(Class)}.
*
* Invoking this method will trump any previous calls to this method or to {@link #ofType(Class)}.
*
* @param represents the runtime class of the desired non-option argument type
* @param aConverter the converter to use
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws NullPointerException if the converter is {@code null}
*/
@SuppressWarnings( "unchecked" )
public final NonOptionArgumentSpec withValuesConvertedBy( ValueConverter aConverter ) {
if ( aConverter == null )
throw new NullPointerException( "illegal null converter" );
converter = (ValueConverter) aConverter;
return (NonOptionArgumentSpec) this;
}
/**
* Specifies a description for the non-option arguments that this spec represents. This description is used
* when generating help information about the parser.
*
* @param description describes the nature of the argument of this spec's option
* @return self, so that the caller can add clauses to the fluent interface sentence
*/
public NonOptionArgumentSpec describedAs( String description ) {
argumentDescription = description;
return this;
}
@Override
protected final V convert( String argument ) {
return convertWith( converter, argument );
}
@Override
void handleOption( OptionParser parser, ArgumentList arguments, OptionSet detectedOptions,
String detectedArgument ) {
detectedOptions.addWithArgument( this, detectedArgument );
}
public List defaultValues() {
return emptyList();
}
public boolean isRequired() {
return false;
}
public boolean acceptsArguments() {
return false;
}
public boolean requiresArgument() {
return false;
}
public String argumentDescription() {
return argumentDescription;
}
public String argumentTypeIndicator() {
return argumentTypeIndicatorFrom( converter );
}
public boolean representsNonOptions() {
return true;
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionArgumentConversionException.java 0000664 0000000 0000000 00000003433 13131706656 0032624 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import static java.util.Collections.*;
/**
* Thrown when a problem occurs converting an argument of an option from {@link String} to another type.
*
* @author Paul Holser
*/
class OptionArgumentConversionException extends OptionException {
private static final long serialVersionUID = -1L;
private final String argument;
OptionArgumentConversionException( OptionSpec options, String argument, Throwable cause ) {
super( singleton( options ), cause );
this.argument = argument;
}
@Override
Object[] messageArguments() {
return new Object[] { argument, singleOptionString() };
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionDeclarer.java 0000664 0000000 0000000 00000011500 13131706656 0026630 0 ustar 00root root 0000000 0000000 package joptsimple;
import java.util.List;
/**
* Trains the option parser. This interface aids integration that disposes declaration of options but not actual
* command-line parsing.
*
* Typical use is for another class to implement {@code OptionDeclarer} as a facade, forwarding calls to an
* {@code OptionParser} instance.
*
* Note that although this is an interface, the returned values of calls are concrete jopt-simple classes.
*
* @author Paul Holser
* @see OptionParser
* @since 4.6
*/
public interface OptionDeclarer {
/**
* Tells the parser to recognize the given option.
*
* This method returns an instance of {@link OptionSpecBuilder} to allow the formation of parser directives
* as sentences in a fluent interface language. For example:
*
*
* OptionDeclarer parser = new OptionParser();
* parser.accepts( "c" ).withRequiredArg().ofType( Integer.class );
*
*
* If no methods are invoked on the returned {@link OptionSpecBuilder}, then the parser treats the option as
* accepting no argument.
*
* @param option the option to recognize
* @return an object that can be used to flesh out more detail about the option
* @throws OptionException if the option contains illegal characters
* @throws NullPointerException if the option is {@code null}
*/
OptionSpecBuilder accepts( String option );
/**
* Tells the parser to recognize the given option.
*
* @see #accepts(String)
* @param option the option to recognize
* @param description a string that describes the purpose of the option. This is used when generating help
* information about the parser.
* @return an object that can be used to flesh out more detail about the option
* @throws OptionException if the option contains illegal characters
* @throws NullPointerException if the option is {@code null}
*/
OptionSpecBuilder accepts( String option, String description );
/**
* Tells the parser to recognize the given options, and treat them as synonymous.
*
* @see #accepts(String)
* @param options the options to recognize and treat as synonymous
* @return an object that can be used to flesh out more detail about the options
* @throws OptionException if any of the options contain illegal characters
* @throws NullPointerException if the option list or any of its elements are {@code null}
*/
OptionSpecBuilder acceptsAll( List options );
/**
* Tells the parser to recognize the given options, and treat them as synonymous.
*
* @see #acceptsAll(List)
* @param options the options to recognize and treat as synonymous
* @param description a string that describes the purpose of the option. This is used when generating help
* information about the parser.
* @return an object that can be used to flesh out more detail about the options
* @throws OptionException if any of the options contain illegal characters
* @throws NullPointerException if the option list or any of its elements are {@code null}
* @throws IllegalArgumentException if the option list is empty
*/
OptionSpecBuilder acceptsAll( List options, String description );
/**
* Gives an object that represents an access point for non-option arguments on a command line.
*
* @return an object that can be used to flesh out more detail about the non-option arguments
*/
NonOptionArgumentSpec nonOptions();
/**
* Gives an object that represents an access point for non-option arguments on a command line.
*
* @see #nonOptions()
* @param description a string that describes the purpose of the non-option arguments. This is used when generating
* help information about the parser.
* @return an object that can be used to flesh out more detail about the non-option arguments
*/
NonOptionArgumentSpec nonOptions( String description );
/**
* Tells the parser whether or not to behave "POSIX-ly correct"-ly.
*
* @param setting {@code true} if the parser should behave "POSIX-ly correct"-ly
*/
void posixlyCorrect( boolean setting );
/**
* Tells the parser to treat unrecognized options as non-option arguments.
*
* If not called, then the parser raises an {@link OptionException} when it encounters an unrecognized
* option.
*/
void allowsUnrecognizedOptions();
/**
* Tells the parser either to recognize or ignore {@code -W}-style long options.
*
* @param recognize {@code true} if the parser is to recognize the special style of long options
*/
void recognizeAlternativeLongOptions( boolean recognize );
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionDescriptor.java 0000664 0000000 0000000 00000006135 13131706656 0027235 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
/**
* Describes options that an option parser recognizes, in ways that might be useful to {@linkplain HelpFormatter
* help screens}.
*
* @author Paul Holser
*/
public interface OptionDescriptor {
/**
* A set of options that are mutually synonymous.
*
* @return synonymous options
*/
List options();
/**
* Description of this option's purpose.
*
* @return a description for the option
*/
String description();
/**
* What values will the option take if none are specified on the command line?
*
* @return any default values for the option
*/
List defaultValues();
/**
* Is this option {@linkplain ArgumentAcceptingOptionSpec#required() required} on a command line?
*
* @return whether the option is required
*/
boolean isRequired();
/**
* Does this option {@linkplain ArgumentAcceptingOptionSpec accept arguments}?
*
* @return whether the option accepts arguments
*/
boolean acceptsArguments();
/**
* Does this option {@linkplain OptionSpecBuilder#withRequiredArg() require an argument}?
*
* @return whether the option requires an argument
*/
boolean requiresArgument();
/**
* Gives a short {@linkplain ArgumentAcceptingOptionSpec#describedAs(String) description} of the option's argument.
*
* @return a description for the option's argument
*/
String argumentDescription();
/**
* Gives an indication of the {@linkplain ArgumentAcceptingOptionSpec#ofType(Class) expected type} of the option's
* argument.
*
* @return a description for the option's argument type
*/
String argumentTypeIndicator();
/**
* Tells whether this object represents the non-option arguments of a command line.
*
* @return {@code true} if this represents non-option arguments
*/
boolean representsNonOptions();
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionException.java 0000664 0000000 0000000 00000007770 13131706656 0027063 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import joptsimple.internal.Strings;
import static java.util.Collections.*;
import static joptsimple.internal.Messages.*;
/**
* Thrown when a problem occurs during option parsing.
*
* @author Paul Holser
*/
public abstract class OptionException extends RuntimeException {
private static final long serialVersionUID = -1L;
private final List options = new ArrayList<>();
protected OptionException( List options ) {
this.options.addAll( options );
}
protected OptionException( Collection> options ) {
this.options.addAll( specsToStrings( options ) );
}
protected OptionException( Collection> options, Throwable cause ) {
super( cause );
this.options.addAll( specsToStrings( options ) );
}
private List specsToStrings( Collection> options ) {
List strings = new ArrayList<>();
for ( OptionSpec each : options )
strings.add( specToString( each ) );
return strings;
}
private String specToString( OptionSpec option ) {
return Strings.join( new ArrayList<>( option.options() ), "/" );
}
/**
* Gives the option being considered when the exception was created.
*
* @return the option being considered when the exception was created
*/
public List options() {
return unmodifiableList( options );
}
protected final String singleOptionString() {
return singleOptionString( options.get( 0 ) );
}
protected final String singleOptionString( String option ) {
return option;
}
protected final String multipleOptionString() {
StringBuilder buffer = new StringBuilder( "[" );
Set asSet = new LinkedHashSet( options );
for ( Iterator iter = asSet.iterator(); iter.hasNext(); ) {
buffer.append( singleOptionString(iter.next()) );
if ( iter.hasNext() )
buffer.append( ", " );
}
buffer.append( ']' );
return buffer.toString();
}
static OptionException unrecognizedOption( String option ) {
return new UnrecognizedOptionException( option );
}
@Override
public final String getMessage() {
return localizedMessage( Locale.getDefault() );
}
final String localizedMessage( Locale locale ) {
return formattedMessage( locale );
}
private String formattedMessage( Locale locale ) {
return message( locale, "joptsimple.ExceptionMessages", getClass(), "message", messageArguments() );
}
abstract Object[] messageArguments();
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionMissingRequiredArgumentException.java 0000664 0000000 0000000 00000003242 13131706656 0033607 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import static java.util.Arrays.*;
/**
* Thrown when the option parser discovers options that require an argument, but are missing an argument.
*
* @author Paul Holser
*/
class OptionMissingRequiredArgumentException extends OptionException {
private static final long serialVersionUID = -1L;
OptionMissingRequiredArgumentException( OptionSpec option ) {
super( asList( option ) );
}
@Override
Object[] messageArguments() {
return new Object[] { singleOptionString() };
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionParser.java 0000664 0000000 0000000 00000064743 13131706656 0026364 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.*;
import joptsimple.internal.AbbreviationMap;
import joptsimple.internal.SimpleOptionNameMap;
import joptsimple.internal.OptionNameMap;
import joptsimple.util.KeyValuePair;
import static java.util.Collections.*;
import static joptsimple.OptionException.*;
import static joptsimple.OptionParserState.*;
import static joptsimple.ParserRules.*;
/**
* Parses command line arguments, using a syntax that attempts to take from the best of POSIX {@code getopt()}
* and GNU {@code getopt_long()}.
*
* This parser supports short options and long options.
*
*
*
* There are two ways to tell the parser what options to recognize:
*
*
* - A "fluent interface"-style API for specifying options, available since version 2. Sentences in this fluent
* interface language begin with a call to {@link #accepts(String) accepts} or {@link #acceptsAll(List)
* acceptsAll} methods; calls on the ensuing chain of objects describe whether the options can take an argument,
* whether the argument is required or optional, to what type arguments of the options should be converted if any,
* etc. Since version 3, these calls return an instance of {@link OptionSpec}, which can subsequently be used to
* retrieve the arguments of the associated option in a type-safe manner.
*
* - Since version 1, a more concise way of specifying short options has been to use the special {@linkplain
* #OptionParser(String) constructor}. Arguments of options specified in this manner will be of type {@link String}.
* Here are the rules for the format of the specification strings this constructor accepts:
*
*
* - Any letter or digit is treated as an option character.
*
* - An option character can be immediately followed by an asterisk ({@code *)} to indicate that
* the option is a "help" option.
*
* - If an option character (with possible trailing asterisk) is followed by a single colon ({@code ":"}),
* then the option requires an argument.
*
* - If an option character (with possible trailing asterisk) is followed by two colons ({@code "::"}),
* then the option accepts an optional argument.
*
* - Otherwise, the option character accepts no argument.
*
* - If the option specification string begins with a plus sign ({@code "+" }), the parser will behave
* "POSIX-ly correct".
*
* - If the option specification string contains the sequence {@code "W;"} (capital W followed by a
* semicolon), the parser will recognize the alternative form of long options.
*
*
*
*
* Each of the options in a list of options given to {@link #acceptsAll(List) acceptsAll} is treated as a
* synonym of the others. For example:
*
*
* OptionParser parser = new OptionParser();
* parser.acceptsAll( asList( "w", "interactive", "confirmation" ) );
* OptionSet options = parser.parse( "-w" );
*
*
* In this case, options.{@link OptionSet#has(String) has} would answer {@code true} when given arguments
* {@code "w"}, {@code "interactive"}, and {@code "confirmation"}. The {@link OptionSet} would give the same
* responses to these arguments for its other methods as well.
*
* By default, as with GNU {@code getopt()}, the parser allows intermixing of options and non-options. If, however,
* the parser has been created to be "POSIX-ly correct", then the first argument that does not look lexically like an
* option, and is not a required argument of a preceding option, signals the end of options. You can still bind
* optional arguments to their options using the abutting (for short options) or {@code =} syntax.
*
* Unlike GNU {@code getopt()}, this parser does not honor the environment variable {@code POSIXLY_CORRECT}.
* "POSIX-ly correct" parsers are configured by either:
*
*
* - using the method {@link #posixlyCorrect(boolean)}, or
*
* - using the {@linkplain #OptionParser(String) constructor} with an argument whose first character is a plus sign
* ({@code "+"})
*
*
* @author Paul Holser
* @see The GNU C Library
*/
public class OptionParser implements OptionDeclarer {
private final OptionNameMap> recognizedOptions;
private final ArrayList> trainingOrder;
private final Map, Set>> requiredIf;
private final Map, Set>> requiredUnless;
private final Map, Set>> availableIf;
private final Map, Set>> availableUnless;
private OptionParserState state;
private boolean posixlyCorrect;
private boolean allowsUnrecognizedOptions;
private HelpFormatter helpFormatter = new BuiltinHelpFormatter();
/**
* Creates an option parser that initially recognizes no options, and does not exhibit "POSIX-ly correct"
* behavior.
*/
public OptionParser() {
this(true);
}
/**
* Creates an option parser that initially recognizes no options, and does not exhibit "POSIX-ly correct"
* behavior.
*
* @param allowAbbreviations whether unambiguous abbreviations of long options should be recognized
* by the parser
*/
public OptionParser( boolean allowAbbreviations ) {
trainingOrder = new ArrayList<>();
requiredIf = new HashMap<>();
requiredUnless = new HashMap<>();
availableIf = new HashMap<>();
availableUnless = new HashMap<>();
state = moreOptions( false );
recognizedOptions = allowAbbreviations
? new AbbreviationMap>()
: new SimpleOptionNameMap>();
recognize( new NonOptionArgumentSpec() );
}
/**
* Creates an option parser and configures it to recognize the short options specified in the given string.
*
* Arguments of options specified this way will be of type {@link String}.
*
* @param optionSpecification an option specification
* @throws NullPointerException if {@code optionSpecification} is {@code null}
* @throws OptionException if the option specification contains illegal characters or otherwise cannot be
* recognized
*/
public OptionParser( String optionSpecification ) {
this();
new OptionSpecTokenizer( optionSpecification ).configure( this );
}
public OptionSpecBuilder accepts( String option ) {
return acceptsAll( singletonList( option ) );
}
public OptionSpecBuilder accepts( String option, String description ) {
return acceptsAll( singletonList( option ), description );
}
public OptionSpecBuilder acceptsAll( List options ) {
return acceptsAll( options, "" );
}
public OptionSpecBuilder acceptsAll( List options, String description ) {
if ( options.isEmpty() )
throw new IllegalArgumentException( "need at least one option" );
ensureLegalOptions( options );
return new OptionSpecBuilder( this, options, description );
}
public NonOptionArgumentSpec nonOptions() {
NonOptionArgumentSpec spec = new NonOptionArgumentSpec<>();
recognize( spec );
return spec;
}
public NonOptionArgumentSpec nonOptions( String description ) {
NonOptionArgumentSpec spec = new NonOptionArgumentSpec<>( description );
recognize( spec );
return spec;
}
public void posixlyCorrect( boolean setting ) {
posixlyCorrect = setting;
state = moreOptions( setting );
}
boolean posixlyCorrect() {
return posixlyCorrect;
}
public void allowsUnrecognizedOptions() {
allowsUnrecognizedOptions = true;
}
boolean doesAllowsUnrecognizedOptions() {
return allowsUnrecognizedOptions;
}
public void recognizeAlternativeLongOptions( boolean recognize ) {
if ( recognize )
recognize( new AlternativeLongOptionSpec() );
else
recognizedOptions.remove( String.valueOf( RESERVED_FOR_EXTENSIONS ) );
}
void recognize( AbstractOptionSpec spec ) {
recognizedOptions.putAll( spec.options(), spec );
trainingOrder.add( spec );
}
/**
* Writes information about the options this parser recognizes to the given output sink.
*
* The output sink is flushed, but not closed.
*
* @param sink the sink to write information to
* @throws IOException if there is a problem writing to the sink
* @throws NullPointerException if {@code sink} is {@code null}
* @see #printHelpOn(Writer)
*/
public void printHelpOn( OutputStream sink ) throws IOException {
printHelpOn( new OutputStreamWriter( sink ) );
}
/**
* Writes information about the options this parser recognizes to the given output sink.
*
* The output sink is flushed, but not closed.
*
* @param sink the sink to write information to
* @throws IOException if there is a problem writing to the sink
* @throws NullPointerException if {@code sink} is {@code null}
* @see #printHelpOn(OutputStream)
*/
public void printHelpOn( Writer sink ) throws IOException {
sink.write( helpFormatter.format( _recognizedOptions() ) );
sink.flush();
}
/**
* Tells the parser to use the given formatter when asked to {@linkplain #printHelpOn(java.io.Writer) print help}.
*
* @param formatter the formatter to use for printing help
* @throws NullPointerException if the formatter is {@code null}
*/
public void formatHelpWith( HelpFormatter formatter ) {
if ( formatter == null )
throw new NullPointerException();
helpFormatter = formatter;
}
/**
* Retrieves all options-spec pairings which have been configured for the parser in the same order as declared
* during training. Option flags for specs are alphabetized by {@link OptionSpec#options()}; only the order of the
* specs is preserved.
*
* (Note: prior to 4.7 the order was alphabetical across all options regardless of spec.)
*
* @return a map containing all the configured options and their corresponding {@link OptionSpec}
* @since 4.6
*/
public Map> recognizedOptions() {
return new LinkedHashMap>( _recognizedOptions() );
}
private Map> _recognizedOptions() {
Map> options = new LinkedHashMap<>();
for ( AbstractOptionSpec spec : trainingOrder ) {
for ( String option : spec.options() )
options.put( option, spec );
}
return options;
}
/**
* Parses the given command line arguments according to the option specifications given to the parser.
*
* @param arguments arguments to parse
* @return an {@link OptionSet} describing the parsed options, their arguments, and any non-option arguments found
* @throws OptionException if problems are detected while parsing
* @throws NullPointerException if the argument list is {@code null}
*/
public OptionSet parse( String... arguments ) {
ArgumentList argumentList = new ArgumentList( arguments );
OptionSet detected = new OptionSet( recognizedOptions.toJavaUtilMap() );
detected.add( recognizedOptions.get( NonOptionArgumentSpec.NAME ) );
while ( argumentList.hasMore() )
state.handleArgument( this, argumentList, detected );
reset();
ensureRequiredOptions( detected );
ensureAllowedOptions( detected );
return detected;
}
/**
* Mandates mutual exclusiveness for the options built by the specified builders.
*
* @param specs descriptors for options that should be mutually exclusive on a command line.
* @throws NullPointerException if {@code specs} is {@code null}
*/
public void mutuallyExclusive( OptionSpecBuilder... specs ) {
for ( int i = 0; i < specs.length; i++ ) {
for ( int j = 0; j < specs.length; j++ ) {
if ( i != j )
specs[i].availableUnless( specs[j] );
}
}
}
private void ensureRequiredOptions( OptionSet options ) {
List> missingRequiredOptions = missingRequiredOptions(options);
boolean helpOptionPresent = isHelpOptionPresent( options );
if ( !missingRequiredOptions.isEmpty() && !helpOptionPresent )
throw new MissingRequiredOptionsException( missingRequiredOptions );
}
private void ensureAllowedOptions( OptionSet options ) {
List> forbiddenOptions = unavailableOptions( options );
boolean helpOptionPresent = isHelpOptionPresent( options );
if ( !forbiddenOptions.isEmpty() && !helpOptionPresent )
throw new UnavailableOptionException( forbiddenOptions );
}
private List> missingRequiredOptions( OptionSet options ) {
List> missingRequiredOptions = new ArrayList<>();
for ( AbstractOptionSpec each : recognizedOptions.toJavaUtilMap().values() ) {
if ( each.isRequired() && !options.has( each ) )
missingRequiredOptions.add(each);
}
for ( Map.Entry, Set>> each : requiredIf.entrySet() ) {
AbstractOptionSpec required = specFor( each.getKey().iterator().next() );
if ( optionsHasAnyOf( options, each.getValue() ) && !options.has( required ) )
missingRequiredOptions.add( required );
}
for ( Map.Entry, Set>> each : requiredUnless.entrySet() ) {
AbstractOptionSpec required = specFor(each.getKey().iterator().next());
if ( !optionsHasAnyOf( options, each.getValue() ) && !options.has( required ) )
missingRequiredOptions.add( required );
}
return missingRequiredOptions;
}
private List> unavailableOptions(OptionSet options) {
List> unavailableOptions = new ArrayList<>();
for ( Map.Entry, Set>> eachEntry : availableIf.entrySet() ) {
AbstractOptionSpec forbidden = specFor( eachEntry.getKey().iterator().next() );
if ( !optionsHasAnyOf( options, eachEntry.getValue() ) && options.has( forbidden ) ) {
unavailableOptions.add(forbidden);
}
}
for ( Map.Entry, Set>> eachEntry : availableUnless.entrySet() ) {
AbstractOptionSpec forbidden = specFor( eachEntry.getKey().iterator().next() );
if ( optionsHasAnyOf( options, eachEntry.getValue() ) && options.has( forbidden ) ) {
unavailableOptions.add(forbidden);
}
}
return unavailableOptions;
}
private boolean optionsHasAnyOf( OptionSet options, Collection> specs ) {
for ( OptionSpec each : specs ) {
if ( options.has( each ) )
return true;
}
return false;
}
private boolean isHelpOptionPresent( OptionSet options ) {
boolean helpOptionPresent = false;
for ( AbstractOptionSpec each : recognizedOptions.toJavaUtilMap().values() ) {
if ( each.isForHelp() && options.has( each ) ) {
helpOptionPresent = true;
break;
}
}
return helpOptionPresent;
}
void handleLongOptionToken( String candidate, ArgumentList arguments, OptionSet detected ) {
KeyValuePair optionAndArgument = parseLongOptionWithArgument( candidate );
if ( !isRecognized( optionAndArgument.key ) )
throw unrecognizedOption( optionAndArgument.key );
AbstractOptionSpec optionSpec = specFor( optionAndArgument.key );
optionSpec.handleOption( this, arguments, detected, optionAndArgument.value );
}
void handleShortOptionToken( String candidate, ArgumentList arguments, OptionSet detected ) {
KeyValuePair optionAndArgument = parseShortOptionWithArgument( candidate );
if ( isRecognized( optionAndArgument.key ) ) {
specFor( optionAndArgument.key ).handleOption( this, arguments, detected, optionAndArgument.value );
}
else
handleShortOptionCluster( candidate, arguments, detected );
}
private void handleShortOptionCluster( String candidate, ArgumentList arguments, OptionSet detected ) {
char[] options = extractShortOptionsFrom( candidate );
validateOptionCharacters( options );
for ( int i = 0; i < options.length; i++ ) {
AbstractOptionSpec optionSpec = specFor( options[ i ] );
if ( optionSpec.acceptsArguments() && options.length > i + 1 ) {
String detectedArgument = String.valueOf( options, i + 1, options.length - 1 - i );
optionSpec.handleOption( this, arguments, detected, detectedArgument );
break;
}
optionSpec.handleOption( this, arguments, detected, null );
}
}
void handleNonOptionArgument( String candidate, ArgumentList arguments, OptionSet detectedOptions ) {
specFor( NonOptionArgumentSpec.NAME ).handleOption( this, arguments, detectedOptions, candidate );
}
void noMoreOptions() {
state = OptionParserState.noMoreOptions();
}
boolean looksLikeAnOption( String argument ) {
return isShortOptionToken( argument ) || isLongOptionToken( argument );
}
boolean isRecognized( String option ) {
return recognizedOptions.contains( option );
}
void requiredIf( List precedentSynonyms, String required ) {
requiredIf( precedentSynonyms, specFor( required ) );
}
void requiredIf( List precedentSynonyms, OptionSpec required ) {
putDependentOption( precedentSynonyms, required, requiredIf );
}
void requiredUnless( List precedentSynonyms, String required ) {
requiredUnless( precedentSynonyms, specFor( required ) );
}
void requiredUnless( List precedentSynonyms, OptionSpec required ) {
putDependentOption( precedentSynonyms, required, requiredUnless );
}
void availableIf( List precedentSynonyms, String available ) {
availableIf( precedentSynonyms, specFor( available ) );
}
void availableIf( List precedentSynonyms, OptionSpec available) {
putDependentOption( precedentSynonyms, available, availableIf );
}
void availableUnless( List precedentSynonyms, String available ) {
availableUnless( precedentSynonyms, specFor( available ) );
}
void availableUnless( List precedentSynonyms, OptionSpec available ) {
putDependentOption( precedentSynonyms, available, availableUnless );
}
private void putDependentOption( List precedentSynonyms, OptionSpec required,
Map, Set>> target ) {
for ( String each : precedentSynonyms ) {
AbstractOptionSpec spec = specFor( each );
if ( spec == null )
throw new UnconfiguredOptionException( precedentSynonyms );
}
Set> associated = target.get( precedentSynonyms );
if ( associated == null ) {
associated = new HashSet<>();
target.put( precedentSynonyms, associated );
}
associated.add( required );
}
private AbstractOptionSpec specFor( char option ) {
return specFor( String.valueOf( option ) );
}
private AbstractOptionSpec specFor( String option ) {
return recognizedOptions.get( option );
}
private void reset() {
state = moreOptions( posixlyCorrect );
}
private static char[] extractShortOptionsFrom( String argument ) {
char[] options = new char[ argument.length() - 1 ];
argument.getChars( 1, argument.length(), options, 0 );
return options;
}
private void validateOptionCharacters( char[] options ) {
for ( char each : options ) {
String option = String.valueOf( each );
if ( !isRecognized( option ) )
throw unrecognizedOption( option );
if ( specFor( option ).acceptsArguments() )
return;
}
}
private static KeyValuePair parseLongOptionWithArgument( String argument ) {
return KeyValuePair.valueOf( argument.substring( 2 ) );
}
private static KeyValuePair parseShortOptionWithArgument( String argument ) {
return KeyValuePair.valueOf( argument.substring( 1 ) );
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionParserState.java 0000664 0000000 0000000 00000006133 13131706656 0027352 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import static joptsimple.ParserRules.*;
/**
* Abstraction of parser state; mostly serves to model how a parser behaves depending on whether end-of-options
* has been detected.
*
* @author Paul Holser
*/
abstract class OptionParserState {
static OptionParserState noMoreOptions() {
return new OptionParserState() {
@Override
protected void handleArgument( OptionParser parser, ArgumentList arguments, OptionSet detectedOptions ) {
parser.handleNonOptionArgument( arguments.next(), arguments, detectedOptions );
}
};
}
static OptionParserState moreOptions( final boolean posixlyCorrect ) {
return new OptionParserState() {
@Override
protected void handleArgument( OptionParser parser, ArgumentList arguments, OptionSet detectedOptions ) {
String candidate = arguments.next();
try {
if ( isOptionTerminator( candidate ) ) {
parser.noMoreOptions();
return;
} else if ( isLongOptionToken( candidate ) ) {
parser.handleLongOptionToken( candidate, arguments, detectedOptions );
return;
} else if ( isShortOptionToken( candidate ) ) {
parser.handleShortOptionToken( candidate, arguments, detectedOptions );
return;
}
} catch ( UnrecognizedOptionException e ) {
if ( !parser.doesAllowsUnrecognizedOptions() )
throw e;
}
if ( posixlyCorrect )
parser.noMoreOptions();
parser.handleNonOptionArgument( candidate, arguments, detectedOptions );
}
};
}
protected abstract void handleArgument( OptionParser parser, ArgumentList arguments, OptionSet detectedOptions );
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionSet.java 0000664 0000000 0000000 00000031340 13131706656 0025646 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import static java.util.Collections.*;
import static java.util.Objects.*;
/**
* Representation of a group of detected command line options, their arguments, and non-option arguments.
*
* @author Paul Holser
*/
public class OptionSet {
private final List> detectedSpecs;
private final Map> detectedOptions;
private final Map, List> optionsToArguments;
private final Map> recognizedSpecs;
private final Map> defaultValues;
/*
* Package-private because clients don't create these.
*/
OptionSet( Map> recognizedSpecs ) {
detectedSpecs = new ArrayList<>();
detectedOptions = new HashMap<>();
optionsToArguments = new IdentityHashMap<>();
defaultValues = defaultValues( recognizedSpecs );
this.recognizedSpecs = recognizedSpecs;
}
/**
* Tells whether any options were detected.
*
* @return {@code true} if any options were detected
*/
public boolean hasOptions() {
return !( detectedOptions.size() == 1 && detectedOptions.values().iterator().next().representsNonOptions() );
}
/**
* Tells whether the given option was detected.
*
* @param option the option to search for
* @return {@code true} if the option was detected
* @see #has(OptionSpec)
*/
public boolean has( String option ) {
return detectedOptions.containsKey( option );
}
/**
* Tells whether the given option was detected.
*
* This method recognizes only instances of options returned from the fluent interface methods.
*
* Specifying a {@linkplain ArgumentAcceptingOptionSpec#defaultsTo(Object, Object[])} default argument value}
* for an option does not cause this method to return {@code true} if the option was not detected on the command
* line.
*
* @param option the option to search for
* @return {@code true} if the option was detected
* @see #has(String)
*/
public boolean has( OptionSpec option ) {
return optionsToArguments.containsKey( option );
}
/**
* Tells whether there are any arguments associated with the given option.
*
* @param option the option to search for
* @return {@code true} if the option was detected and at least one argument was detected for the option
* @see #hasArgument(OptionSpec)
*/
public boolean hasArgument( String option ) {
AbstractOptionSpec spec = detectedOptions.get( option );
return spec != null && hasArgument( spec );
}
/**
* Tells whether there are any arguments associated with the given option.
*
* This method recognizes only instances of options returned from the fluent interface methods.
*
* Specifying a {@linkplain ArgumentAcceptingOptionSpec#defaultsTo(Object, Object[]) default argument value}
* for an option does not cause this method to return {@code true} if the option was not detected on the command
* line, or if the option can take an optional argument but did not have one on the command line.
*
* @param option the option to search for
* @return {@code true} if the option was detected and at least one argument was detected for the option
* @throws NullPointerException if {@code option} is {@code null}
* @see #hasArgument(String)
*/
public boolean hasArgument( OptionSpec option ) {
requireNonNull( option );
List values = optionsToArguments.get( option );
return values != null && !values.isEmpty();
}
/**
* Gives the argument associated with the given option. If the option was given an argument type, the argument
* will take on that type; otherwise, it will be a {@link String}.
*
* Specifying a {@linkplain ArgumentAcceptingOptionSpec#defaultsTo(Object, Object[]) default argument value}
* for an option will cause this method to return that default value even if the option was not detected on the
* command line, or if the option can take an optional argument but did not have one on the command line.
*
* @param option the option to search for
* @return the argument of the given option; {@code null} if no argument is present, or that option was not
* detected
* @throws NullPointerException if {@code option} is {@code null}
* @throws OptionException if more than one argument was detected for the option
*/
public Object valueOf( String option ) {
requireNonNull( option );
AbstractOptionSpec spec = detectedOptions.get( option );
if ( spec == null ) {
List defaults = defaultValuesFor( option );
return defaults.isEmpty() ? null : defaults.get( 0 );
}
return valueOf( spec );
}
/**
* Gives the argument associated with the given option.
*
* This method recognizes only instances of options returned from the fluent interface methods.
*
* @param represents the type of the arguments the given option accepts
* @param option the option to search for
* @return the argument of the given option; {@code null} if no argument is present, or that option was not
* detected
* @throws OptionException if more than one argument was detected for the option
* @throws NullPointerException if {@code option} is {@code null}
* @throws ClassCastException if the arguments of this option are not of the expected type
*/
public V valueOf( OptionSpec option ) {
requireNonNull( option );
List values = valuesOf( option );
switch ( values.size() ) {
case 0:
return null;
case 1:
return values.get( 0 );
default:
throw new MultipleArgumentsForOptionException( option );
}
}
/**
* Gives any arguments associated with the given option. If the option was given an argument type, the
* arguments will take on that type; otherwise, they will be {@link String}s.
*
* @param option the option to search for
* @return the arguments associated with the option, as a list of objects of the type given to the arguments; an
* empty list if no such arguments are present, or if the option was not detected
* @throws NullPointerException if {@code option} is {@code null}
*/
public List valuesOf( String option ) {
requireNonNull( option );
AbstractOptionSpec spec = detectedOptions.get( option );
return spec == null ? defaultValuesFor( option ) : valuesOf( spec );
}
/**
* Gives any arguments associated with the given option. If the option was given an argument type, the
* arguments will take on that type; otherwise, they will be {@link String}s.
*
* This method recognizes only instances of options returned from the fluent interface methods.
*
* @param represents the type of the arguments the given option accepts
* @param option the option to search for
* @return the arguments associated with the option; an empty list if no such arguments are present, or if the
* option was not detected
* @throws NullPointerException if {@code option} is {@code null}
* @throws OptionException if there is a problem converting the option's arguments to the desired type; for
* example, if the type does not implement a correct conversion constructor or method
*/
public List valuesOf( OptionSpec option ) {
requireNonNull( option );
List values = optionsToArguments.get( option );
if ( values == null || values.isEmpty() )
return defaultValueFor( option );
AbstractOptionSpec spec = (AbstractOptionSpec) option;
List convertedValues = new ArrayList<>();
for ( String each : values )
convertedValues.add( spec.convert( each ) );
return unmodifiableList( convertedValues );
}
/**
* Gives the set of options that were detected, in the form of {@linkplain OptionSpec}s, in the order in which the
* options were found on the command line.
*
* @return the set of detected command line options
*/
public List> specs() {
List> specs = detectedSpecs;
specs.removeAll( singletonList( detectedOptions.get( NonOptionArgumentSpec.NAME ) ) );
return unmodifiableList( specs );
}
/**
* Gives all declared options as a map of string to {@linkplain OptionSpec}.
*
* @return the declared options as a map
*/
public Map, List> asMap() {
Map, List> map = new HashMap<>();
for ( AbstractOptionSpec spec : recognizedSpecs.values() ) {
if ( !spec.representsNonOptions() )
map.put( spec, valuesOf( spec ) );
}
return unmodifiableMap( map );
}
/**
* @return the detected non-option arguments
*/
public List nonOptionArguments() {
AbstractOptionSpec spec = detectedOptions.get( NonOptionArgumentSpec.NAME );
return valuesOf( spec );
}
void add( AbstractOptionSpec spec ) {
addWithArgument( spec, null );
}
void addWithArgument( AbstractOptionSpec spec, String argument ) {
detectedSpecs.add( spec );
for ( String each : spec.options() )
detectedOptions.put( each, spec );
List optionArguments = optionsToArguments.get( spec );
if ( optionArguments == null ) {
optionArguments = new ArrayList<>();
optionsToArguments.put( spec, optionArguments );
}
if ( argument != null )
optionArguments.add( argument );
}
@Override
public boolean equals( Object that ) {
if ( this == that )
return true;
if ( that == null || !getClass().equals( that.getClass() ) )
return false;
OptionSet other = (OptionSet) that;
Map, List> thisOptionsToArguments = new HashMap<>( optionsToArguments );
Map, List> otherOptionsToArguments = new HashMap<>( other.optionsToArguments );
return detectedOptions.equals( other.detectedOptions )
&& thisOptionsToArguments.equals( otherOptionsToArguments );
}
@Override
public int hashCode() {
Map, List> thisOptionsToArguments = new HashMap<>( optionsToArguments );
return detectedOptions.hashCode() ^ thisOptionsToArguments.hashCode();
}
@SuppressWarnings( "unchecked" )
private List defaultValuesFor( String option ) {
if ( defaultValues.containsKey( option ) )
return unmodifiableList( (List) defaultValues.get( option ) );
return emptyList();
}
private List defaultValueFor( OptionSpec option ) {
return defaultValuesFor( option.options().iterator().next() );
}
private static Map> defaultValues( Map> recognizedSpecs ) {
Map> defaults = new HashMap<>();
for ( Map.Entry> each : recognizedSpecs.entrySet() )
defaults.put( each.getKey(), each.getValue().defaultValues() );
return defaults;
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionSpec.java 0000664 0000000 0000000 00000010767 13131706656 0026017 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
/**
* Describes options that an option parser recognizes.
*
* Instances of this interface are returned by the "fluent interface" methods to allow retrieval of option arguments
* in a type-safe manner. Here's an example:
*
*
* OptionParser parser = new OptionParser();
* OptionSpec<Integer> count =
* parser.accepts( "count" ).withRequiredArg().ofType( Integer.class );
* OptionSet options = parser.parse( "--count", "2" );
* assert options.has( count );
* int countValue = options.valueOf( count );
* assert countValue == count.value( options );
* List<Integer> countValues = options.valuesOf( count );
* assert countValues.equals( count.values( options ) );
*
*
* @param represents the type of the arguments this option accepts
* @author Paul Holser
*/
public interface OptionSpec {
/**
* Gives any arguments associated with the given option in the given set of detected options.
*
* Specifying a {@linkplain ArgumentAcceptingOptionSpec#defaultsTo(Object, Object[]) default argument value}
* for this option will cause this method to return that default value even if this option was not detected on the
* command line, or if this option can take an optional argument but did not have one on the command line.
*
* @param detectedOptions the detected options to search in
* @return the arguments associated with this option; an empty list if no such arguments are present, or if this
* option was not detected
* @throws OptionException if there is a problem converting this option's arguments to the desired type; for
* example, if the type does not implement a correct conversion constructor or method
* @throws NullPointerException if {@code detectedOptions} is {@code null}
* @see OptionSet#valuesOf(OptionSpec)
*/
List values( OptionSet detectedOptions );
/**
* Gives the argument associated with the given option in the given set of detected options.
*
* Specifying a {@linkplain ArgumentAcceptingOptionSpec#defaultsTo(Object, Object[]) default argument value}
* for this option will cause this method to return that default value even if this option was not detected on the
* command line, or if this option can take an optional argument but did not have one on the command line.
*
* @param detectedOptions the detected options to search in
* @return the argument of the this option; {@code null} if no argument is present, or that option was not detected
* @throws OptionException if more than one argument was detected for the option
* @throws NullPointerException if {@code detectedOptions} is {@code null}
* @throws ClassCastException if the arguments of this option are not of the expected type
* @see OptionSet#valueOf(OptionSpec)
*/
V value( OptionSet detectedOptions );
/**
* @return the string representations of this option
*/
List options();
/**
* Tells whether this option is designated as a "help" option. The presence of a "help" option on a command line
* means that missing "required" options will not cause parsing to fail.
*
* @return whether this option is designated as a "help" option
*/
boolean isForHelp();
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionSpecBuilder.java 0000664 0000000 0000000 00000030015 13131706656 0027312 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Allows callers to specify whether a given option accepts arguments (required or optional).
*
* Instances are returned from {@link OptionParser#accepts(String)} to allow the formation of parser directives as
* sentences in a "fluent interface" language. For example:
*
*
* OptionParser parser = new OptionParser();
* parser.accepts( "c" ).withRequiredArg().ofType( Integer.class );
*
*
* If no methods are invoked on an instance of this class, then that instance's option will accept no argument.
*
* Note that you should not use the fluent interface clauses in a way that would defeat the typing of option
* arguments:
*
*
* OptionParser parser = new OptionParser();
* ArgumentAcceptingOptionSpec<String> optionC =
* parser.accepts( "c" ).withRequiredArg();
* optionC.ofType( Integer.class ); // DON'T THROW AWAY THE TYPE!
*
* String value = parser.parse( "-c", "2" ).valueOf( optionC ); // ClassCastException
*
*
* @author Paul Holser
*/
public class OptionSpecBuilder extends NoArgumentOptionSpec {
private final OptionParser parser;
OptionSpecBuilder( OptionParser parser, List options, String description ) {
super( options, description );
this.parser = parser;
attachToParser();
}
private void attachToParser() {
parser.recognize( this );
}
/**
* Informs an option parser that this builder's option requires an argument.
*
* @return a specification for the option
*/
public ArgumentAcceptingOptionSpec withRequiredArg() {
ArgumentAcceptingOptionSpec newSpec = new RequiredArgumentOptionSpec<>( options(), description() );
parser.recognize( newSpec );
return newSpec;
}
/**
* Informs an option parser that this builder's option accepts an optional argument.
*
* @return a specification for the option
*/
public ArgumentAcceptingOptionSpec withOptionalArg() {
ArgumentAcceptingOptionSpec newSpec =
new OptionalArgumentOptionSpec<>( options(), description() );
parser.recognize( newSpec );
return newSpec;
}
/**
* Informs an option parser that this builder's option is required if the given option is present on the command
* line.
*
* For a given option, you should not mix this with {@link #requiredUnless(String, String...)
* requiredUnless} to avoid conflicts.
*
* @param dependent an option whose presence on a command line makes this builder's option required
* @param otherDependents other options whose presence on a command line makes this builder's option required
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws OptionException if any of the dependent options haven't been configured in the parser yet
*/
public OptionSpecBuilder requiredIf( String dependent, String... otherDependents ) {
List dependents = validatedDependents( dependent, otherDependents );
for ( String each : dependents )
parser.requiredIf( options(), each );
return this;
}
/**
* Informs an option parser that this builder's option is required if the given option is present on the command
* line.
*
* For a given option, you should not mix this with {@link #requiredUnless(OptionSpec, OptionSpec[])
* requiredUnless} to avoid conflicts.
*
* This method recognizes only instances of options returned from the fluent interface methods.
*
* @param dependent the option whose presence on a command line makes this builder's option required
* @param otherDependents other options whose presence on a command line makes this builder's option required
* @return self, so that the caller can add clauses to the fluent interface sentence
*/
public OptionSpecBuilder requiredIf( OptionSpec dependent, OptionSpec... otherDependents ) {
parser.requiredIf( options(), dependent );
for ( OptionSpec each : otherDependents )
parser.requiredIf( options(), each );
return this;
}
/**
* Informs an option parser that this builder's option is required if the given option is absent on the command
* line.
*
* For a given option, you should not mix this with {@link #requiredIf(OptionSpec, OptionSpec[])
* requiredIf} to avoid conflicts.
*
* @param dependent an option whose absence on a command line makes this builder's option required
* @param otherDependents other options whose absence on a command line makes this builder's option required
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws OptionException if any of the dependent options haven't been configured in the parser yet
*/
public OptionSpecBuilder requiredUnless( String dependent, String... otherDependents ) {
List dependents = validatedDependents( dependent, otherDependents );
for ( String each : dependents ) {
parser.requiredUnless( options(), each );
}
return this;
}
/**
* Informs an option parser that this builder's option is required if the given option is absent on the command
* line.
*
* For a given option, you should not mix this with {@link #requiredIf(OptionSpec, OptionSpec[])
* requiredIf} to avoid conflicts.
*
* This method recognizes only instances of options returned from the fluent interface methods.
*
* @param dependent the option whose absence on a command line makes this builder's option required
* @param otherDependents other options whose absence on a command line makes this builder's option required
* @return self, so that the caller can add clauses to the fluent interface sentence
*/
public OptionSpecBuilder requiredUnless( OptionSpec dependent, OptionSpec... otherDependents ) {
parser.requiredUnless( options(), dependent );
for ( OptionSpec each : otherDependents )
parser.requiredUnless( options(), each );
return this;
}
/**
* Informs an option parser that this builder's option is allowed if the given option is present on the command
* line.
*
* For a given option, you should not mix this with {@link #availableUnless(String, String...)
* availableUnless} to avoid conflicts.
*
* @param dependent an option whose presence on a command line makes this builder's option allowed
* @param otherDependents other options whose presence on a command line makes this builder's option allowed
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws OptionException if any of the dependent options haven't been configured in the parser yet
*/
public OptionSpecBuilder availableIf( String dependent, String... otherDependents ) {
List dependents = validatedDependents( dependent, otherDependents );
for ( String each : dependents )
parser.availableIf( options(), each );
return this;
}
/**
* Informs an option parser that this builder's option is allowed if the given option is present on the command
* line.
*
* For a given option, you should not mix this with {@link #availableUnless(OptionSpec, OptionSpec[])
* requiredUnless} to avoid conflicts.
*
* This method recognizes only instances of options returned from the fluent interface methods.
*
* @param dependent the option whose presence on a command line makes this builder's option allowed
* @param otherDependents other options whose presence on a command line makes this builder's option allowed
* @return self, so that the caller can add clauses to the fluent interface sentence
*/
public OptionSpecBuilder availableIf( OptionSpec dependent, OptionSpec... otherDependents ) {
parser.availableIf( options(), dependent );
for ( OptionSpec each : otherDependents )
parser.availableIf( options(), each );
return this;
}
/**
* Informs an option parser that this builder's option is allowed if the given option is absent on the command
* line.
*
* For a given option, you should not mix this with {@link #availableIf(OptionSpec, OptionSpec[])
* requiredIf} to avoid conflicts.
*
* @param dependent an option whose absence on a command line makes this builder's option allowed
* @param otherDependents other options whose absence on a command line makes this builder's option allowed
* @return self, so that the caller can add clauses to the fluent interface sentence
* @throws OptionException if any of the dependent options haven't been configured in the parser yet
*/
public OptionSpecBuilder availableUnless( String dependent, String... otherDependents ) {
List dependents = validatedDependents( dependent, otherDependents );
for ( String each : dependents )
parser.availableUnless( options(), each );
return this;
}
/**
* Informs an option parser that this builder's option is allowed if the given option is absent on the command
* line.
*
* For a given option, you should not mix this with {@link #availableIf(OptionSpec, OptionSpec[])
* requiredIf} to avoid conflicts.
*
* This method recognizes only instances of options returned from the fluent interface methods.
*
* @param dependent the option whose absence on a command line makes this builder's option allowed
* @param otherDependents other options whose absence on a command line makes this builder's option allowed
* @return self, so that the caller can add clauses to the fluent interface sentence
*/
public OptionSpecBuilder availableUnless( OptionSpec dependent, OptionSpec... otherDependents ) {
parser.availableUnless( options(), dependent );
for ( OptionSpec each : otherDependents )
parser.availableUnless(options(), each);
return this;
}
private List validatedDependents( String dependent, String... otherDependents ) {
List dependents = new ArrayList<>();
dependents.add( dependent );
Collections.addAll( dependents, otherDependents );
for ( String each : dependents ) {
if ( !parser.isRecognized( each ) )
throw new UnconfiguredOptionException( each );
}
return dependents;
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionSpecTokenizer.java 0000664 0000000 0000000 00000007626 13131706656 0027712 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.NoSuchElementException;
import static joptsimple.ParserRules.*;
/**
* Tokenizes a short option specification string.
*
* @author Paul Holser
*/
class OptionSpecTokenizer {
private static final char POSIXLY_CORRECT_MARKER = '+';
private static final char HELP_MARKER = '*';
private String specification;
private int index;
OptionSpecTokenizer( String specification ) {
if ( specification == null )
throw new NullPointerException( "null option specification" );
this.specification = specification;
}
boolean hasMore() {
return index < specification.length();
}
AbstractOptionSpec next() {
if ( !hasMore() )
throw new NoSuchElementException();
String optionCandidate = String.valueOf( specification.charAt( index ) );
index++;
AbstractOptionSpec spec;
if ( RESERVED_FOR_EXTENSIONS.equals( optionCandidate ) ) {
spec = handleReservedForExtensionsToken();
if ( spec != null )
return spec;
}
ensureLegalOption( optionCandidate );
if ( hasMore() ) {
boolean forHelp = false;
if ( specification.charAt( index ) == HELP_MARKER ) {
forHelp = true;
++index;
}
spec = hasMore() && specification.charAt( index ) == ':'
? handleArgumentAcceptingOption( optionCandidate )
: new NoArgumentOptionSpec( optionCandidate );
if ( forHelp )
spec.forHelp();
} else
spec = new NoArgumentOptionSpec( optionCandidate );
return spec;
}
void configure( OptionParser parser ) {
adjustForPosixlyCorrect( parser );
while ( hasMore() )
parser.recognize( next() );
}
private void adjustForPosixlyCorrect( OptionParser parser ) {
if ( POSIXLY_CORRECT_MARKER == specification.charAt( 0 ) ) {
parser.posixlyCorrect( true );
specification = specification.substring( 1 );
}
}
private AbstractOptionSpec handleReservedForExtensionsToken() {
if ( !hasMore() )
return new NoArgumentOptionSpec( RESERVED_FOR_EXTENSIONS );
if ( specification.charAt( index ) == ';' ) {
++index;
return new AlternativeLongOptionSpec();
}
return null;
}
private AbstractOptionSpec handleArgumentAcceptingOption( String candidate ) {
index++;
if ( hasMore() && specification.charAt( index ) == ':' ) {
index++;
return new OptionalArgumentOptionSpec( candidate );
}
return new RequiredArgumentOptionSpec( candidate );
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/OptionalArgumentOptionSpec.java 0000664 0000000 0000000 00000005162 13131706656 0031221 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
/**
* Specification of an option that accepts an optional argument.
*
* @param represents the type of the arguments this option accepts
* @author Paul Holser
*/
class OptionalArgumentOptionSpec extends ArgumentAcceptingOptionSpec {
OptionalArgumentOptionSpec( String option ) {
super( option, false );
}
OptionalArgumentOptionSpec( List options, String description ) {
super( options, false, description );
}
@Override
protected void detectOptionArgument( OptionParser parser, ArgumentList arguments, OptionSet detectedOptions ) {
if ( arguments.hasMore() ) {
String nextArgument = arguments.peek();
if ( !parser.looksLikeAnOption( nextArgument ) && canConvertArgument( nextArgument ) )
handleOptionArgument( parser, detectedOptions, arguments );
else if ( isArgumentOfNumberType() && canConvertArgument( nextArgument ) )
addArguments( detectedOptions, arguments.next() );
else
detectedOptions.add( this );
}
else
detectedOptions.add( this );
}
private void handleOptionArgument( OptionParser parser, OptionSet detectedOptions, ArgumentList arguments ) {
if ( parser.posixlyCorrect() ) {
detectedOptions.add( this );
parser.noMoreOptions();
}
else
addArguments( detectedOptions, arguments.next() );
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/ParserRules.java 0000664 0000000 0000000 00000005757 13131706656 0026206 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
import static java.lang.Character.*;
/**
* Can tell whether or not options are well-formed.
*
* @author Paul Holser
*/
final class ParserRules {
static final char HYPHEN_CHAR = '-';
static final String HYPHEN = String.valueOf( HYPHEN_CHAR );
static final String DOUBLE_HYPHEN = "--";
static final String OPTION_TERMINATOR = DOUBLE_HYPHEN;
static final String RESERVED_FOR_EXTENSIONS = "W";
private ParserRules() {
throw new UnsupportedOperationException();
}
static boolean isShortOptionToken( String argument ) {
return argument.startsWith( HYPHEN )
&& !HYPHEN.equals( argument )
&& !isLongOptionToken( argument );
}
static boolean isLongOptionToken( String argument ) {
return argument.startsWith( DOUBLE_HYPHEN ) && !isOptionTerminator( argument );
}
static boolean isOptionTerminator( String argument ) {
return OPTION_TERMINATOR.equals( argument );
}
static void ensureLegalOption( String option ) {
if ( option.startsWith( HYPHEN ) )
throw new IllegalOptionSpecificationException( String.valueOf( option ) );
for ( int i = 0; i < option.length(); ++i )
ensureLegalOptionCharacter( option.charAt( i ) );
}
static void ensureLegalOptions( List options ) {
for ( String each : options )
ensureLegalOption( each );
}
private static void ensureLegalOptionCharacter( char option ) {
if ( !( isLetterOrDigit( option ) || isAllowedPunctuation( option ) ) )
throw new IllegalOptionSpecificationException( String.valueOf( option ) );
}
private static boolean isAllowedPunctuation( char option ) {
String allowedPunctuation = "?._" + HYPHEN_CHAR;
return allowedPunctuation.indexOf( option ) != -1;
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/RequiredArgumentOptionSpec.java 0000664 0000000 0000000 00000003657 13131706656 0031223 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
/**
* Specification of an option that accepts a required argument.
*
* @param represents the type of the arguments this option accepts
* @author Paul Holser
*/
class RequiredArgumentOptionSpec extends ArgumentAcceptingOptionSpec {
RequiredArgumentOptionSpec( String option ) {
super( option, true );
}
RequiredArgumentOptionSpec( List options, String description ) {
super( options, true, description );
}
@Override
protected void detectOptionArgument( OptionParser parser, ArgumentList arguments, OptionSet detectedOptions ) {
if ( !arguments.hasMore() )
throw new OptionMissingRequiredArgumentException( this );
addArguments( detectedOptions, arguments.next() );
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/UnavailableOptionException.java 0000664 0000000 0000000 00000003163 13131706656 0031217 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
/**
* Thrown when options marked as allowed are specified on the command line, but the options they depend upon are
* present/not present.
*/
class UnavailableOptionException extends OptionException {
private static final long serialVersionUID = -1L;
UnavailableOptionException( List> forbiddenOptions ) {
super( forbiddenOptions );
}
@Override
Object[] messageArguments() {
return new Object[] { multipleOptionString() };
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/UnconfiguredOptionException.java 0000664 0000000 0000000 00000003405 13131706656 0031423 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import java.util.List;
import static java.util.Collections.*;
/**
* Thrown when an option parser refers to an option that is not in fact configured already on the parser.
*
* @author Paul Holser
*/
class UnconfiguredOptionException extends OptionException {
private static final long serialVersionUID = -1L;
UnconfiguredOptionException( String option ) {
this( singletonList( option ) );
}
UnconfiguredOptionException( List options ) {
super( options );
}
@Override
Object[] messageArguments() {
return new Object[] { multipleOptionString() };
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/UnrecognizedOptionException.java 0000664 0000000 0000000 00000003153 13131706656 0031427 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
import static java.util.Collections.*;
/**
* Thrown when the option parser encounters an unrecognized option.
*
* @author Paul Holser
*/
class UnrecognizedOptionException extends OptionException {
private static final long serialVersionUID = -1L;
UnrecognizedOptionException( String option ) {
super( singletonList( option ) );
}
@Override
Object[] messageArguments() {
return new Object[] { singleOptionString() };
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/ValueConversionException.java 0000664 0000000 0000000 00000003645 13131706656 0030732 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
/**
* Thrown by {@link ValueConverter}s when problems occur in converting string values to other Java types.
*
* @author Paul Holser
*/
public class ValueConversionException extends RuntimeException {
private static final long serialVersionUID = -1L;
/**
* Creates a new exception with the specified detail message.
*
* @param message the detail message
*/
public ValueConversionException( String message ) {
this( message, null );
}
/**
* Creates a new exception with the specified detail message and cause.
*
* @param message the detail message
* @param cause the original exception
*/
public ValueConversionException( String message, Throwable cause ) {
super( message, cause );
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/ValueConverter.java 0000664 0000000 0000000 00000004242 13131706656 0026667 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple;
/**
* Instances of this interface are used to convert arguments of options into specific Java types.
*
* @param constraint on the type of values being converted to
* @author Paul Holser
*/
public interface ValueConverter {
/**
* Converts the given string value into a Java type.
*
* @param value the string to convert
* @return the converted value
* @throws ValueConversionException if a problem occurs while converting the value
*/
V convert( String value );
/**
* Gives the class of the type of values this converter converts to.
*
* @return the target class for conversion
*/
Class valueType();
/**
* Gives a string that describes the pattern of the values this converter expects, if any. For example, a date
* converter can respond with a {@link java.text.SimpleDateFormat date format string}.
*
* @return a value pattern, or {@code null} if there's nothing interesting here
*/
String valuePattern();
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal/ 0000775 0000000 0000000 00000000000 13131706656 0024672 5 ustar 00root root 0000000 0000000 jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal/AbbreviationMap.java 0000664 0000000 0000000 00000020064 13131706656 0030602 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple.internal;
import java.util.Map;
import java.util.TreeMap;
/**
* A map whose keys are strings; when a key/value pair is added to the map, the longest unique abbreviations of that
* key are added as well, and associated with the value. Thus:
*
*
*
* abbreviations.put( "good", "bye" );
*
*
*
* would make it such that you could retrieve the value {@code "bye"} from the map using the keys {@code "good"},
* {@code "goo"}, {@code "go"}, and {@code "g"}. A subsequent invocation of:
*
*
* abbreviations.put( "go", "fish" );
*
*
*
* would make it such that you could retrieve the value {@code "bye"} using the keys {@code "good"} and
* {@code "goo"}, and the value {@code "fish"} using the key {@code "go"}. The key {@code "g"} would yield
* {@code null}, since it would no longer be a unique abbreviation.
*
* The data structure is much like a "trie".
*
* @param a constraint on the types of the values in the map
* @author Paul Holser
* @see Perl's Text::Abbrev module
* @see Radix tree
*/
public class AbbreviationMap implements OptionNameMap {
private final Map> children = new TreeMap<>();
private String key;
private V value;
private int keysBeyond;
/**
* Tells whether the given key is in the map, or whether the given key is a unique
* abbreviation of a key that is in the map.
*
* @param key key to look up
* @return {@code true} if {@code key} is present in the map
* @throws NullPointerException if {@code key} is {@code null}
*/
@Override
public boolean contains(String key) {
return get(key) != null;
}
/**
* Answers the value associated with the given key. The key can be a unique
* abbreviation of a key that is in the map.
*
* @param key key to look up
* @return the value associated with {@code aKey}; or {@code null} if there is no
* such value or {@code aKey} is not a unique abbreviation of a key in the map
* @throws NullPointerException if {@code aKey} is {@code null}
*/
@Override
public V get( String key ) {
char[] chars = charsOf( key );
AbbreviationMap child = this;
for ( char each : chars ) {
child = child.children.get( each );
if ( child == null )
return null;
}
return child.value;
}
/**
* Associates a given value with a given key. If there was a previous
* association, the old value is replaced with the new one.
*
* @param key key to create in the map
* @param newValue value to associate with the key
* @throws NullPointerException if {@code aKey} or {@code newValue} is {@code null}
* @throws IllegalArgumentException if {@code aKey} is a zero-length string
*/
@Override
public void put( String key, V newValue ) {
if ( newValue == null )
throw new NullPointerException();
if ( key.length() == 0 )
throw new IllegalArgumentException();
char[] chars = charsOf(key);
add( chars, newValue, 0, chars.length );
}
/**
* Associates a given value with a given set of keys. If there was a previous
* association, the old value is replaced with the new one.
*
* @param keys keys to create in the map
* @param newValue value to associate with the key
* @throws NullPointerException if {@code keys} or {@code newValue} is {@code null}
* @throws IllegalArgumentException if any of {@code keys} is a zero-length string
*/
@Override
public void putAll( Iterable keys, V newValue ) {
for ( String each : keys )
put( each, newValue );
}
private boolean add( char[] chars, V newValue, int offset, int length ) {
if ( offset == length ) {
value = newValue;
boolean wasAlreadyAKey = key != null;
key = new String( chars );
return !wasAlreadyAKey;
}
char nextChar = chars[ offset ];
AbbreviationMap child = children.get( nextChar );
if ( child == null ) {
child = new AbbreviationMap<>();
children.put( nextChar, child );
}
boolean newKeyAdded = child.add( chars, newValue, offset + 1, length );
if ( newKeyAdded )
++keysBeyond;
if ( key == null )
value = keysBeyond > 1 ? null : newValue;
return newKeyAdded;
}
/**
* If the map contains the given key, dissociates the key from its value.
*
* @param key key to remove
* @throws NullPointerException if {@code aKey} is {@code null}
* @throws IllegalArgumentException if {@code aKey} is a zero-length string
*/
@Override
public void remove( String key ) {
if ( key.length() == 0 )
throw new IllegalArgumentException();
char[] keyChars = charsOf(key);
remove( keyChars, 0, keyChars.length );
}
private boolean remove( char[] aKey, int offset, int length ) {
if ( offset == length )
return removeAtEndOfKey();
char nextChar = aKey[ offset ];
AbbreviationMap child = children.get( nextChar );
if ( child == null || !child.remove( aKey, offset + 1, length ) )
return false;
--keysBeyond;
if ( child.keysBeyond == 0 )
children.remove( nextChar );
if ( keysBeyond == 1 && key == null )
setValueToThatOfOnlyChild();
return true;
}
private void setValueToThatOfOnlyChild() {
Map.Entry> entry = children.entrySet().iterator().next();
AbbreviationMap onlyChild = entry.getValue();
value = onlyChild.value;
}
private boolean removeAtEndOfKey() {
if ( key == null )
return false;
key = null;
if ( keysBeyond == 1 )
setValueToThatOfOnlyChild();
else
value = null;
return true;
}
/**
* Gives a Java map representation of this abbreviation map.
*
* @return a Java map corresponding to this abbreviation map
*/
@Override
public Map toJavaUtilMap() {
Map mappings = new TreeMap<>();
addToMappings( mappings );
return mappings;
}
private void addToMappings( Map mappings ) {
if ( key != null )
mappings.put( key, value );
for ( AbbreviationMap each : children.values() )
each.addToMappings( mappings );
}
private static char[] charsOf( String aKey ) {
char[] chars = new char[ aKey.length() ];
aKey.getChars( 0, aKey.length(), chars, 0 );
return chars;
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal/Classes.java 0000664 0000000 0000000 00000005377 13131706656 0027146 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple.internal;
import java.util.HashMap;
import java.util.Map;
/**
* @author Paul Holser
*/
public final class Classes {
private static final Map, Class> WRAPPERS = new HashMap<>( 13 );
static {
WRAPPERS.put( boolean.class, Boolean.class );
WRAPPERS.put( byte.class, Byte.class );
WRAPPERS.put( char.class, Character.class );
WRAPPERS.put( double.class, Double.class );
WRAPPERS.put( float.class, Float.class );
WRAPPERS.put( int.class, Integer.class );
WRAPPERS.put( long.class, Long.class );
WRAPPERS.put( short.class, Short.class );
WRAPPERS.put( void.class, Void.class );
}
private Classes() {
throw new UnsupportedOperationException();
}
/**
* Gives the "short version" of the given class name. Somewhat naive to inner classes.
*
* @param className class name to chew on
* @return the short name of the class
*/
public static String shortNameOf( String className ) {
return className.substring( className.lastIndexOf( '.' ) + 1 );
}
/**
* Gives the primitive wrapper class for the given class. If the given class is not
* {@linkplain Class#isPrimitive() primitive}, returns the class itself.
*
* @param generic class type
* @param clazz the class to check
* @return primitive wrapper type if {@code clazz} is primitive, otherwise {@code clazz}
*/
@SuppressWarnings( "unchecked" )
public static Class wrapperOf( Class clazz ) {
return clazz.isPrimitive() ? (Class) WRAPPERS.get( clazz ) : clazz;
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal/Columns.java 0000664 0000000 0000000 00000007223 13131706656 0027161 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple.internal;
import java.text.BreakIterator;
import java.util.ArrayList;
import java.util.List;
import static java.text.BreakIterator.*;
import static joptsimple.internal.Strings.*;
/**
* @author Paul Holser
*/
class Columns {
private static final int INDENT_WIDTH = 2;
private final int optionWidth;
private final int descriptionWidth;
Columns( int optionWidth, int descriptionWidth ) {
this.optionWidth = optionWidth;
this.descriptionWidth = descriptionWidth;
}
List fit( Row row ) {
List options = piecesOf( row.option, optionWidth );
List descriptions = piecesOf( row.description, descriptionWidth );
List rows = new ArrayList<>();
for ( int i = 0; i < Math.max( options.size(), descriptions.size() ); ++i )
rows.add( new Row( itemOrEmpty( options, i ), itemOrEmpty( descriptions, i ) ) );
return rows;
}
private static String itemOrEmpty( List items, int index ) {
return index >= items.size() ? "" : items.get( index );
}
private List piecesOf( String raw, int width ) {
List pieces = new ArrayList<>();
for ( String each : raw.trim().split( LINE_SEPARATOR ) )
pieces.addAll( piecesOfEmbeddedLine( each, width ) );
return pieces;
}
private List piecesOfEmbeddedLine( String line, int width ) {
List pieces = new ArrayList<>();
BreakIterator words = BreakIterator.getLineInstance();
words.setText( line );
StringBuilder nextPiece = new StringBuilder();
int start = words.first();
for ( int end = words.next(); end != DONE; start = end, end = words.next() )
nextPiece = processNextWord( line, nextPiece, start, end, width, pieces );
if ( nextPiece.length() > 0 )
pieces.add( nextPiece.toString() );
return pieces;
}
private StringBuilder processNextWord( String source, StringBuilder nextPiece, int start, int end, int width,
List pieces ) {
StringBuilder augmented = nextPiece;
String word = source.substring( start, end );
if ( augmented.length() + word.length() > width ) {
pieces.add( augmented.toString().replaceAll( "\\s+$", "" ) );
augmented = new StringBuilder( repeat( ' ', INDENT_WIDTH ) ).append( word );
}
else
augmented.append( word );
return augmented;
}
}
ConstructorInvokingValueConverter.java 0000664 0000000 0000000 00000003472 13131706656 0034403 0 ustar 00root root 0000000 0000000 jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple.internal;
import java.lang.reflect.Constructor;
import joptsimple.ValueConverter;
import static joptsimple.internal.Reflection.*;
/**
* @param constraint on the type of values being converted to
* @author Paul Holser
*/
class ConstructorInvokingValueConverter implements ValueConverter {
private final Constructor ctor;
ConstructorInvokingValueConverter( Constructor ctor ) {
this.ctor = ctor;
}
public V convert( String value ) {
return instantiate( ctor, value );
}
public Class valueType() {
return ctor.getDeclaringClass();
}
public String valuePattern() {
return null;
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal/Messages.java 0000664 0000000 0000000 00000003442 13131706656 0027307 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple.internal;
import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;
/**
* @author Paul Holser
*/
public class Messages {
private Messages() {
throw new UnsupportedOperationException();
}
public static String message( Locale locale, String bundleName, Class type, String key, Object... args ) {
ResourceBundle bundle = ResourceBundle.getBundle( bundleName, locale );
String template = bundle.getString( type.getName() + '.' + key );
MessageFormat format = new MessageFormat( template );
format.setLocale( locale );
return format.format( args );
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal/MethodInvokingValueConverter.java 0000664 0000000 0000000 00000003551 13131706656 0033353 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple.internal;
import java.lang.reflect.Method;
import joptsimple.ValueConverter;
import static joptsimple.internal.Reflection.*;
/**
* @param constraint on the type of values being converted to
* @author Paul Holser
*/
class MethodInvokingValueConverter implements ValueConverter {
private final Method method;
private final Class clazz;
MethodInvokingValueConverter( Method method, Class clazz ) {
this.method = method;
this.clazz = clazz;
}
public V convert( String value ) {
return clazz.cast( invoke( method, value ) );
}
public Class valueType() {
return clazz;
}
public String valuePattern() {
return null;
}
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal/OptionNameMap.java 0000664 0000000 0000000 00000003004 13131706656 0030241 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple.internal;
import java.util.Map;
/**
* Map-like interface for storing String-value pairs.
*
* @param type of values stored in the map
*/
public interface OptionNameMap {
boolean contains( String key );
V get( String key );
void put( String key, V newValue );
void putAll( Iterable keys, V newValue );
void remove( String key );
Map toJavaUtilMap();
}
jopt-simple-jopt-simple-5.0.4/src/main/java/joptsimple/internal/Reflection.java 0000664 0000000 0000000 00000012076 13131706656 0027635 0 ustar 00root root 0000000 0000000 /*
The MIT License
Copyright (c) 2004-2015 Paul R. Holser, Jr.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package joptsimple.internal;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import static java.lang.reflect.Modifier.*;
import joptsimple.ValueConverter;
import static joptsimple.internal.Classes.*;
/**
* Helper methods for reflection.
*
* @author Paul Holser
*/
public final class Reflection {
private Reflection() {
throw new UnsupportedOperationException();
}
/**
* Finds an appropriate value converter for the given class.
*
* @param a constraint on the class object to introspect
* @param clazz class to introspect on
* @return a converter method or constructor
*/
public static ValueConverter findConverter( Class clazz ) {
Class maybeWrapper = wrapperOf( clazz );
ValueConverter valueOf = valueOfConverter( maybeWrapper );
if ( valueOf != null )
return valueOf;
ValueConverter constructor = constructorConverter( maybeWrapper );
if ( constructor != null )
return constructor;
throw new IllegalArgumentException( clazz + " is not a value type" );
}
private static ValueConverter valueOfConverter( Class clazz ) {
try {
Method valueOf = clazz.getMethod( "valueOf", String.class );
if ( meetsConverterRequirements( valueOf, clazz ) )
return new MethodInvokingValueConverter<>( valueOf, clazz );
return null;
} catch ( NoSuchMethodException ignored ) {
return null;
}
}
private static