it = matchingOptions.iterator();
while (it.hasNext())
{
buf.append("'");
buf.append(it.next());
buf.append("'");
if (it.hasNext())
{
buf.append(", ");
}
}
buf.append(")");
return buf.toString();
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/BasicParser.java 0100644 0000765 0000024 00000003745 12537250704 027123 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
/**
* The class BasicParser provides a very simple implementation of
* the {@link Parser#flatten(Options,String[],boolean) flatten} method.
*
* @version $Id: BasicParser.java 1443102 2013-02-06 18:12:16Z tn $
* @deprecated since 1.3, use the {@link DefaultParser} instead
*/
@Deprecated
public class BasicParser extends Parser
{
/**
* A simple implementation of {@link Parser}'s abstract
* {@link Parser#flatten(Options, String[], boolean) flatten} method.
*
* Note: options and stopAtNonOption
* are not used in this flatten method.
*
* @param options The command line {@link Options}
* @param arguments The command line arguments to be parsed
* @param stopAtNonOption Specifies whether to stop flattening
* when an non option is found.
* @return The arguments String array.
*/
@Override
protected String[] flatten(@SuppressWarnings("unused") Options options,
String[] arguments,
@SuppressWarnings("unused") boolean stopAtNonOption)
{
// just echo the arguments
return arguments;
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/CommandLine.java 0100644 0000765 0000024 00000025300 12537250704 027102 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
/**
* Represents list of arguments parsed against a {@link Options} descriptor.
*
* It allows querying of a boolean {@link #hasOption(String opt)},
* in addition to retrieving the {@link #getOptionValue(String opt)}
* for options requiring arguments.
*
* Additionally, any left-over or unrecognized arguments,
* are available for further processing.
*
* @version $Id: CommandLine.java 1444365 2013-02-09 14:21:27Z tn $
*/
public class CommandLine implements Serializable
{
/** The serial version UID. */
private static final long serialVersionUID = 1L;
/** the unrecognised options/arguments */
private final List args = new LinkedList();
/** the processed options */
private final List options = new ArrayList ();
/**
* Creates a command line.
*/
protected CommandLine()
{
// nothing to do
}
/**
* Query to see if an option has been set.
*
* @param opt Short name of the option
* @return true if set, false if not
*/
public boolean hasOption(String opt)
{
return options.contains(resolveOption(opt));
}
/**
* Query to see if an option has been set.
*
* @param opt character name of the option
* @return true if set, false if not
*/
public boolean hasOption(char opt)
{
return hasOption(String.valueOf(opt));
}
/**
* Return the Object type of this Option.
*
* @param opt the name of the option
* @return the type of this Option
* @deprecated due to System.err message. Instead use getParsedOptionValue(String)
*/
@Deprecated
public Object getOptionObject(String opt)
{
try
{
return getParsedOptionValue(opt);
}
catch (ParseException pe)
{
System.err.println("Exception found converting " + opt + " to desired type: " + pe.getMessage());
return null;
}
}
/**
* Return a version of this Option converted to a particular type.
*
* @param opt the name of the option
* @return the value parsed into a particular object
* @throws ParseException if there are problems turning the option value into the desired type
* @see PatternOptionBuilder
* @since 1.2
*/
public Object getParsedOptionValue(String opt) throws ParseException
{
String res = getOptionValue(opt);
Option option = resolveOption(opt);
if (option == null || res == null)
{
return null;
}
return TypeHandler.createValue(res, option.getType());
}
/**
* Return the Object type of this Option.
*
* @param opt the name of the option
* @return the type of opt
*/
public Object getOptionObject(char opt)
{
return getOptionObject(String.valueOf(opt));
}
/**
* Retrieve the first argument, if any, of this option.
*
* @param opt the name of the option
* @return Value of the argument if option is set, and has an argument,
* otherwise null.
*/
public String getOptionValue(String opt)
{
String[] values = getOptionValues(opt);
return (values == null) ? null : values[0];
}
/**
* Retrieve the first argument, if any, of this option.
*
* @param opt the character name of the option
* @return Value of the argument if option is set, and has an argument,
* otherwise null.
*/
public String getOptionValue(char opt)
{
return getOptionValue(String.valueOf(opt));
}
/**
* Retrieves the array of values, if any, of an option.
*
* @param opt string name of the option
* @return Values of the argument if option is set, and has an argument,
* otherwise null.
*/
public String[] getOptionValues(String opt)
{
List values = new ArrayList();
for (Option option : options)
{
if (opt.equals(option.getOpt()) || opt.equals(option.getLongOpt()))
{
values.addAll(option.getValuesList());
}
}
return values.isEmpty() ? null : values.toArray(new String[values.size()]);
}
/**
* Retrieves the option object given the long or short option as a String
*
* @param opt short or long name of the option
* @return Canonicalized option
*/
private Option resolveOption(String opt)
{
opt = Util.stripLeadingHyphens(opt);
for (Option option : options)
{
if (opt.equals(option.getOpt()))
{
return option;
}
if (opt.equals(option.getLongOpt()))
{
return option;
}
}
return null;
}
/**
* Retrieves the array of values, if any, of an option.
*
* @param opt character name of the option
* @return Values of the argument if option is set, and has an argument,
* otherwise null.
*/
public String[] getOptionValues(char opt)
{
return getOptionValues(String.valueOf(opt));
}
/**
* Retrieve the first argument, if any, of an option.
*
* @param opt name of the option
* @param defaultValue is the default value to be returned if the option
* is not specified
* @return Value of the argument if option is set, and has an argument,
* otherwise defaultValue.
*/
public String getOptionValue(String opt, String defaultValue)
{
String answer = getOptionValue(opt);
return (answer != null) ? answer : defaultValue;
}
/**
* Retrieve the argument, if any, of an option.
*
* @param opt character name of the option
* @param defaultValue is the default value to be returned if the option
* is not specified
* @return Value of the argument if option is set, and has an argument,
* otherwise defaultValue.
*/
public String getOptionValue(char opt, String defaultValue)
{
return getOptionValue(String.valueOf(opt), defaultValue);
}
/**
* Retrieve the map of values associated to the option. This is convenient
* for options specifying Java properties like -Dparam1=value1
* -Dparam2=value2 . The first argument of the option is the key, and
* the 2nd argument is the value. If the option has only one argument
* (-Dfoo ) it is considered as a boolean flag and the value is
* "true" .
*
* @param opt name of the option
* @return The Properties mapped by the option, never null
* even if the option doesn't exists
* @since 1.2
*/
public Properties getOptionProperties(String opt)
{
Properties props = new Properties();
for (Option option : options)
{
if (opt.equals(option.getOpt()) || opt.equals(option.getLongOpt()))
{
List values = option.getValuesList();
if (values.size() >= 2)
{
// use the first 2 arguments as the key/value pair
props.put(values.get(0), values.get(1));
}
else if (values.size() == 1)
{
// no explicit value, handle it as a boolean
props.put(values.get(0), "true");
}
}
}
return props;
}
/**
* Retrieve any left-over non-recognized options and arguments
*
* @return remaining items passed in but not parsed as an array
*/
public String[] getArgs()
{
String[] answer = new String[args.size()];
args.toArray(answer);
return answer;
}
/**
* Retrieve any left-over non-recognized options and arguments
*
* @return remaining items passed in but not parsed as a List.
*/
public List getArgList()
{
return args;
}
/**
* jkeyes
* - commented out until it is implemented properly
* Dump state, suitable for debugging.
*
* @return Stringified form of this object
*/
/*
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append("[ CommandLine: [ options: ");
buf.append(options.toString());
buf.append(" ] [ args: ");
buf.append(args.toString());
buf.append(" ] ]");
return buf.toString();
}
*/
/**
* Add left-over unrecognized option/argument.
*
* @param arg the unrecognised option/argument.
*/
protected void addArg(String arg)
{
args.add(arg);
}
/**
* Add an option to the command line. The values of the option are stored.
*
* @param opt the processed option
*/
protected void addOption(Option opt)
{
options.add(opt);
}
/**
* Returns an iterator over the Option members of CommandLine.
*
* @return an Iterator over the processed {@link Option}
* members of this {@link CommandLine}
*/
public Iterator iterator()
{
return options.iterator();
}
/**
* Returns an array of the processed {@link Option}s.
*
* @return an array of the processed {@link Option}s.
*/
public Option[] getOptions()
{
Collection processed = options;
// reinitialise array
Option[] optionsArray = new Option[processed.size()];
// return the array
return processed.toArray(optionsArray);
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/CommandLineParser.java 0100644 0000765 0000024 00000007767 12537250704 030300 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
/**
* A class that implements the CommandLineParser interface
* can parse a String array according to the {@link Options} specified
* and return a {@link CommandLine}.
*
* @version $Id: CommandLineParser.java 1443102 2013-02-06 18:12:16Z tn $
*/
public interface CommandLineParser
{
/**
* Parse the arguments according to the specified options.
*
* @param options the specified Options
* @param arguments the command line arguments
* @return the list of atomic option and value tokens
*
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*/
CommandLine parse(Options options, String[] arguments) throws ParseException;
/**
* Parse the arguments according to the specified options and
* properties.
*
* @param options the specified Options
* @param arguments the command line arguments
* @param properties command line option name-value pairs
* @return the list of atomic option and value tokens
*
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*/
/* To maintain binary compatibility, this is commented out.
It is still in the abstract Parser class, so most users will
still reap the benefit.
CommandLine parse(Options options, String[] arguments, Properties properties)
throws ParseException;
*/
/**
* Parse the arguments according to the specified options.
*
* @param options the specified Options
* @param arguments the command line arguments
* @param stopAtNonOption if true an unrecognized argument stops
* the parsing and the remaining arguments are added to the
* {@link CommandLine}s args list. If false an unrecognized
* argument triggers a ParseException.
*
* @return the list of atomic option and value tokens
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*/
CommandLine parse(Options options, String[] arguments, boolean stopAtNonOption) throws ParseException;
/**
* Parse the arguments according to the specified options and
* properties.
*
* @param options the specified Options
* @param arguments the command line arguments
* @param properties command line option name-value pairs
* @param stopAtNonOption if true an unrecognized argument stops
* the parsing and the remaining arguments are added to the
* {@link CommandLine}s args list. If false an unrecognized
* argument triggers a ParseException.
*
* @return the list of atomic option and value tokens
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*/
/* To maintain binary compatibility, this is commented out.
It is still in the abstract Parser class, so most users will
still reap the benefit.
CommandLine parse(Options options, String[] arguments, Properties properties, boolean stopAtNonOption)
throws ParseException;
*/
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/DefaultParser.java 0100644 0000765 0000024 00000047637 12537250704 027476 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
/**
* Default parser.
*
* @version $Id: DefaultParser.java 1677454 2015-05-03 17:13:54Z ggregory $
* @since 1.3
*/
public class DefaultParser implements CommandLineParser
{
/** The command-line instance. */
protected CommandLine cmd;
/** The current options. */
protected Options options;
/**
* Flag indicating how unrecognized tokens are handled. true to stop
* the parsing and add the remaining tokens to the args list.
* false to throw an exception.
*/
protected boolean stopAtNonOption;
/** The token currently processed. */
protected String currentToken;
/** The last option parsed. */
protected Option currentOption;
/** Flag indicating if tokens should no longer be analyzed and simply added as arguments of the command line. */
protected boolean skipParsing;
/** The required options and groups expected to be found when parsing the command line. */
protected List expectedOpts;
public CommandLine parse(Options options, String[] arguments) throws ParseException
{
return parse(options, arguments, null);
}
/**
* Parse the arguments according to the specified options and properties.
*
* @param options the specified Options
* @param arguments the command line arguments
* @param properties command line option name-value pairs
* @return the list of atomic option and value tokens
*
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*/
public CommandLine parse(Options options, String[] arguments, Properties properties) throws ParseException
{
return parse(options, arguments, properties, false);
}
public CommandLine parse(Options options, String[] arguments, boolean stopAtNonOption) throws ParseException
{
return parse(options, arguments, null, stopAtNonOption);
}
/**
* Parse the arguments according to the specified options and properties.
*
* @param options the specified Options
* @param arguments the command line arguments
* @param properties command line option name-value pairs
* @param stopAtNonOption if true an unrecognized argument stops
* the parsing and the remaining arguments are added to the
* {@link CommandLine}s args list. If false an unrecognized
* argument triggers a ParseException.
*
* @return the list of atomic option and value tokens
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*/
public CommandLine parse(Options options, String[] arguments, Properties properties, boolean stopAtNonOption)
throws ParseException
{
this.options = options;
this.stopAtNonOption = stopAtNonOption;
skipParsing = false;
currentOption = null;
expectedOpts = new ArrayList(options.getRequiredOptions());
// clear the data from the groups
for (OptionGroup group : options.getOptionGroups())
{
group.setSelected(null);
}
cmd = new CommandLine();
if (arguments != null)
{
for (String argument : arguments)
{
handleToken(argument);
}
}
// check the arguments of the last option
checkRequiredArgs();
// add the default options
handleProperties(properties);
checkRequiredOptions();
return cmd;
}
/**
* Sets the values of Options using the values in properties.
*
* @param properties The value properties to be processed.
*/
private void handleProperties(Properties properties) throws ParseException
{
if (properties == null)
{
return;
}
for (Enumeration e = properties.propertyNames(); e.hasMoreElements();)
{
String option = e.nextElement().toString();
Option opt = options.getOption(option);
if (opt == null)
{
throw new UnrecognizedOptionException("Default option wasn't defined", option);
}
// if the option is part of a group, check if another option of the group has been selected
OptionGroup group = options.getOptionGroup(opt);
boolean selected = group != null && group.getSelected() != null;
if (!cmd.hasOption(option) && !selected)
{
// get the value from the properties
String value = properties.getProperty(option);
if (opt.hasArg())
{
if (opt.getValues() == null || opt.getValues().length == 0)
{
opt.addValueForProcessing(value);
}
}
else if (!("yes".equalsIgnoreCase(value)
|| "true".equalsIgnoreCase(value)
|| "1".equalsIgnoreCase(value)))
{
// if the value is not yes, true or 1 then don't add the option to the CommandLine
continue;
}
handleOption(opt);
currentOption = null;
}
}
}
/**
* Throws a {@link MissingOptionException} if all of the required options
* are not present.
*
* @throws MissingOptionException if any of the required Options
* are not present.
*/
private void checkRequiredOptions() throws MissingOptionException
{
// if there are required options that have not been processed
if (!expectedOpts.isEmpty())
{
throw new MissingOptionException(expectedOpts);
}
}
/**
* Throw a {@link MissingArgumentException} if the current option
* didn't receive the number of arguments expected.
*/
private void checkRequiredArgs() throws ParseException
{
if (currentOption != null && currentOption.requiresArg())
{
throw new MissingArgumentException(currentOption);
}
}
/**
* Handle any command line token.
*
* @param token the command line token to handle
* @throws ParseException
*/
private void handleToken(String token) throws ParseException
{
currentToken = token;
if (skipParsing)
{
cmd.addArg(token);
}
else if ("--".equals(token))
{
skipParsing = true;
}
else if (currentOption != null && currentOption.acceptsArg() && isArgument(token))
{
currentOption.addValueForProcessing(Util.stripLeadingAndTrailingQuotes(token));
}
else if (token.startsWith("--"))
{
handleLongOption(token);
}
else if (token.startsWith("-") && !"-".equals(token))
{
handleShortAndLongOption(token);
}
else
{
handleUnknownToken(token);
}
if (currentOption != null && !currentOption.acceptsArg())
{
currentOption = null;
}
}
/**
* Returns true is the token is a valid argument.
*
* @param token
*/
private boolean isArgument(String token)
{
return !isOption(token) || isNegativeNumber(token);
}
/**
* Check if the token is a negative number.
*
* @param token
*/
private boolean isNegativeNumber(String token)
{
try
{
Double.parseDouble(token);
return true;
}
catch (NumberFormatException e)
{
return false;
}
}
/**
* Tells if the token looks like an option.
*
* @param token
*/
private boolean isOption(String token)
{
return isLongOption(token) || isShortOption(token);
}
/**
* Tells if the token looks like a short option.
*
* @param token
*/
private boolean isShortOption(String token)
{
// short options (-S, -SV, -S=V, -SV1=V2, -S1S2)
return token.startsWith("-") && token.length() >= 2 && options.hasShortOption(token.substring(1, 2));
}
/**
* Tells if the token looks like a long option.
*
* @param token
*/
private boolean isLongOption(String token)
{
if (!token.startsWith("-") || token.length() == 1)
{
return false;
}
int pos = token.indexOf("=");
String t = pos == -1 ? token : token.substring(0, pos);
if (!options.getMatchingOptions(t).isEmpty())
{
// long or partial long options (--L, -L, --L=V, -L=V, --l, --l=V)
return true;
}
else if (getLongPrefix(token) != null && !token.startsWith("--"))
{
// -LV
return true;
}
return false;
}
/**
* Handles an unknown token. If the token starts with a dash an
* UnrecognizedOptionException is thrown. Otherwise the token is added
* to the arguments of the command line. If the stopAtNonOption flag
* is set, this stops the parsing and the remaining tokens are added
* as-is in the arguments of the command line.
*
* @param token the command line token to handle
*/
private void handleUnknownToken(String token) throws ParseException
{
if (token.startsWith("-") && token.length() > 1 && !stopAtNonOption)
{
throw new UnrecognizedOptionException("Unrecognized option: " + token, token);
}
cmd.addArg(token);
if (stopAtNonOption)
{
skipParsing = true;
}
}
/**
* Handles the following tokens:
*
* --L
* --L=V
* --L V
* --l
*
* @param token the command line token to handle
*/
private void handleLongOption(String token) throws ParseException
{
if (token.indexOf('=') == -1)
{
handleLongOptionWithoutEqual(token);
}
else
{
handleLongOptionWithEqual(token);
}
}
/**
* Handles the following tokens:
*
* --L
* -L
* --l
* -l
*
* @param token the command line token to handle
*/
private void handleLongOptionWithoutEqual(String token) throws ParseException
{
List matchingOpts = options.getMatchingOptions(token);
if (matchingOpts.isEmpty())
{
handleUnknownToken(currentToken);
}
else if (matchingOpts.size() > 1)
{
throw new AmbiguousOptionException(token, matchingOpts);
}
else
{
handleOption(options.getOption(matchingOpts.get(0)));
}
}
/**
* Handles the following tokens:
*
* --L=V
* -L=V
* --l=V
* -l=V
*
* @param token the command line token to handle
*/
private void handleLongOptionWithEqual(String token) throws ParseException
{
int pos = token.indexOf('=');
String value = token.substring(pos + 1);
String opt = token.substring(0, pos);
List matchingOpts = options.getMatchingOptions(opt);
if (matchingOpts.isEmpty())
{
handleUnknownToken(currentToken);
}
else if (matchingOpts.size() > 1)
{
throw new AmbiguousOptionException(opt, matchingOpts);
}
else
{
Option option = options.getOption(matchingOpts.get(0));
if (option.acceptsArg())
{
handleOption(option);
currentOption.addValueForProcessing(value);
currentOption = null;
}
else
{
handleUnknownToken(currentToken);
}
}
}
/**
* Handles the following tokens:
*
* -S
* -SV
* -S V
* -S=V
* -S1S2
* -S1S2 V
* -SV1=V2
*
* -L
* -LV
* -L V
* -L=V
* -l
*
* @param token the command line token to handle
*/
private void handleShortAndLongOption(String token) throws ParseException
{
String t = Util.stripLeadingHyphens(token);
int pos = t.indexOf('=');
if (t.length() == 1)
{
// -S
if (options.hasShortOption(t))
{
handleOption(options.getOption(t));
}
else
{
handleUnknownToken(token);
}
}
else if (pos == -1)
{
// no equal sign found (-xxx)
if (options.hasShortOption(t))
{
handleOption(options.getOption(t));
}
else if (!options.getMatchingOptions(t).isEmpty())
{
// -L or -l
handleLongOptionWithoutEqual(token);
}
else
{
// look for a long prefix (-Xmx512m)
String opt = getLongPrefix(t);
if (opt != null && options.getOption(opt).acceptsArg())
{
handleOption(options.getOption(opt));
currentOption.addValueForProcessing(t.substring(opt.length()));
currentOption = null;
}
else if (isJavaProperty(t))
{
// -SV1 (-Dflag)
handleOption(options.getOption(t.substring(0, 1)));
currentOption.addValueForProcessing(t.substring(1));
currentOption = null;
}
else
{
// -S1S2S3 or -S1S2V
handleConcatenatedOptions(token);
}
}
}
else
{
// equal sign found (-xxx=yyy)
String opt = t.substring(0, pos);
String value = t.substring(pos + 1);
if (opt.length() == 1)
{
// -S=V
Option option = options.getOption(opt);
if (option != null && option.acceptsArg())
{
handleOption(option);
currentOption.addValueForProcessing(value);
currentOption = null;
}
else
{
handleUnknownToken(token);
}
}
else if (isJavaProperty(opt))
{
// -SV1=V2 (-Dkey=value)
handleOption(options.getOption(opt.substring(0, 1)));
currentOption.addValueForProcessing(opt.substring(1));
currentOption.addValueForProcessing(value);
currentOption = null;
}
else
{
// -L=V or -l=V
handleLongOptionWithEqual(token);
}
}
}
/**
* Search for a prefix that is the long name of an option (-Xmx512m)
*
* @param token
*/
private String getLongPrefix(String token)
{
String t = Util.stripLeadingHyphens(token);
int i;
String opt = null;
for (i = t.length() - 2; i > 1; i--)
{
String prefix = t.substring(0, i);
if (options.hasLongOption(prefix))
{
opt = prefix;
break;
}
}
return opt;
}
/**
* Check if the specified token is a Java-like property (-Dkey=value).
*/
private boolean isJavaProperty(String token)
{
String opt = token.substring(0, 1);
Option option = options.getOption(opt);
return option != null && (option.getArgs() >= 2 || option.getArgs() == Option.UNLIMITED_VALUES);
}
private void handleOption(Option option) throws ParseException
{
// check the previous option before handling the next one
checkRequiredArgs();
option = (Option) option.clone();
updateRequiredOptions(option);
cmd.addOption(option);
if (option.hasArg())
{
currentOption = option;
}
else
{
currentOption = null;
}
}
/**
* Removes the option or its group from the list of expected elements.
*
* @param option
*/
private void updateRequiredOptions(Option option) throws AlreadySelectedException
{
if (option.isRequired())
{
expectedOpts.remove(option.getKey());
}
// if the option is in an OptionGroup make that option the selected option of the group
if (options.getOptionGroup(option) != null)
{
OptionGroup group = options.getOptionGroup(option);
if (group.isRequired())
{
expectedOpts.remove(group);
}
group.setSelected(option);
}
}
/**
* Breaks token into its constituent parts
* using the following algorithm.
*
*
* ignore the first character ("- ")
* foreach remaining character check if an {@link Option}
* exists with that id.
* if an {@link Option} does exist then add that character
* prepended with "- " to the list of processed tokens.
* if the {@link Option} can have an argument value and there
* are remaining characters in the token then add the remaining
* characters as a token to the list of processed tokens.
* if an {@link Option} does NOT exist AND
* stopAtNonOption IS set then add the special token
* "-- " followed by the remaining characters and also
* the remaining tokens directly to the processed tokens list.
* if an {@link Option} does NOT exist AND
* stopAtNonOption IS NOT set then add that
* character prepended with "- ".
*
*
* @param token The current token to be burst
* at the first non-Option encountered.
* @throws ParseException if there are any problems encountered
* while parsing the command line token.
*/
protected void handleConcatenatedOptions(String token) throws ParseException
{
for (int i = 1; i < token.length(); i++)
{
String ch = String.valueOf(token.charAt(i));
if (options.hasOption(ch))
{
handleOption(options.getOption(ch));
if (currentOption != null && token.length() != i + 1)
{
// add the trail as an argument of the option
currentOption.addValueForProcessing(token.substring(i + 1));
break;
}
}
else
{
handleUnknownToken(stopAtNonOption && i > 1 ? token.substring(i) : token);
break;
}
}
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/GnuParser.java 0100644 0000765 0000024 00000010067 12537250704 026626 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.util.ArrayList;
import java.util.List;
/**
* The class GnuParser provides an implementation of the
* {@link Parser#flatten(Options, String[], boolean) flatten} method.
*
* @version $Id: GnuParser.java 1445352 2013-02-12 20:48:19Z tn $
* @deprecated since 1.3, use the {@link DefaultParser} instead
*/
@Deprecated
public class GnuParser extends Parser
{
/**
* This flatten method does so using the following rules:
*
* If an {@link Option} exists for the first character of
* the arguments entry AND an {@link Option}
* does not exist for the whole argument then
* add the first character as an option to the processed tokens
* list e.g. "-D" and add the rest of the entry to the also.
* Otherwise just add the token to the processed tokens list.
*
*
* @param options The Options to parse the arguments by.
* @param arguments The arguments that have to be flattened.
* @param stopAtNonOption specifies whether to stop flattening when
* a non option has been encountered
* @return a String array of the flattened arguments
*/
@Override
protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)
{
List tokens = new ArrayList();
boolean eatTheRest = false;
for (int i = 0; i < arguments.length; i++)
{
String arg = arguments[i];
if ("--".equals(arg))
{
eatTheRest = true;
tokens.add("--");
}
else if ("-".equals(arg))
{
tokens.add("-");
}
else if (arg.startsWith("-"))
{
String opt = Util.stripLeadingHyphens(arg);
if (options.hasOption(opt))
{
tokens.add(arg);
}
else
{
if (opt.indexOf('=') != -1 && options.hasOption(opt.substring(0, opt.indexOf('='))))
{
// the format is --foo=value or -foo=value
tokens.add(arg.substring(0, arg.indexOf('='))); // --foo
tokens.add(arg.substring(arg.indexOf('=') + 1)); // value
}
else if (options.hasOption(arg.substring(0, 2)))
{
// the format is a special properties option (-Dproperty=value)
tokens.add(arg.substring(0, 2)); // -D
tokens.add(arg.substring(2)); // property=value
}
else
{
eatTheRest = stopAtNonOption;
tokens.add(arg);
}
}
}
else
{
tokens.add(arg);
}
if (eatTheRest)
{
for (i++; i < arguments.length; i++) //NOPMD
{
tokens.add(arguments[i]);
}
}
}
return tokens.toArray(new String[tokens.size()]);
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/HelpFormatter.java 0100644 0000765 0000024 00000102627 12537250704 027500 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Serializable;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
/**
* A formatter of help messages for command line options.
*
* Example:
*
*
* Options options = new Options();
* options.addOption(OptionBuilder.withLongOpt("file")
* .withDescription("The file to be processed")
* .hasArg()
* .withArgName("FILE")
* .isRequired()
* .create('f'));
* options.addOption(OptionBuilder.withLongOpt("version")
* .withDescription("Print the version of the application")
* .create('v'));
* options.addOption(OptionBuilder.withLongOpt("help").create('h'));
*
* String header = "Do something useful with an input file\n\n";
* String footer = "\nPlease report issues at http://example.com/issues";
*
* HelpFormatter formatter = new HelpFormatter();
* formatter.printHelp("myapp", header, options, footer, true);
*
*
* This produces the following output:
*
*
* usage: myapp -f <FILE> [-h] [-v]
* Do something useful with an input file
*
* -f,--file <FILE> The file to be processed
* -h,--help
* -v,--version Print the version of the application
*
* Please report issues at http://example.com/issues
*
*
* @version $Id: HelpFormatter.java 1677407 2015-05-03 14:31:12Z britter $
*/
public class HelpFormatter
{
// --------------------------------------------------------------- Constants
/** default number of characters per line */
public static final int DEFAULT_WIDTH = 74;
/** default padding to the left of each line */
public static final int DEFAULT_LEFT_PAD = 1;
/** number of space characters to be prefixed to each description line */
public static final int DEFAULT_DESC_PAD = 3;
/** the string to display at the beginning of the usage statement */
public static final String DEFAULT_SYNTAX_PREFIX = "usage: ";
/** default prefix for shortOpts */
public static final String DEFAULT_OPT_PREFIX = "-";
/** default prefix for long Option */
public static final String DEFAULT_LONG_OPT_PREFIX = "--";
/**
* default separator displayed between a long Option and its value
*
* @since 1.3
**/
public static final String DEFAULT_LONG_OPT_SEPARATOR = " ";
/** default name for an argument */
public static final String DEFAULT_ARG_NAME = "arg";
// -------------------------------------------------------------- Attributes
/**
* number of characters per line
*
* @deprecated Scope will be made private for next major version
* - use get/setWidth methods instead.
*/
@Deprecated
public int defaultWidth = DEFAULT_WIDTH;
/**
* amount of padding to the left of each line
*
* @deprecated Scope will be made private for next major version
* - use get/setLeftPadding methods instead.
*/
@Deprecated
public int defaultLeftPad = DEFAULT_LEFT_PAD;
/**
* the number of characters of padding to be prefixed
* to each description line
*
* @deprecated Scope will be made private for next major version
* - use get/setDescPadding methods instead.
*/
@Deprecated
public int defaultDescPad = DEFAULT_DESC_PAD;
/**
* the string to display at the beginning of the usage statement
*
* @deprecated Scope will be made private for next major version
* - use get/setSyntaxPrefix methods instead.
*/
@Deprecated
public String defaultSyntaxPrefix = DEFAULT_SYNTAX_PREFIX;
/**
* the new line string
*
* @deprecated Scope will be made private for next major version
* - use get/setNewLine methods instead.
*/
@Deprecated
public String defaultNewLine = System.getProperty("line.separator");
/**
* the shortOpt prefix
*
* @deprecated Scope will be made private for next major version
* - use get/setOptPrefix methods instead.
*/
@Deprecated
public String defaultOptPrefix = DEFAULT_OPT_PREFIX;
/**
* the long Opt prefix
*
* @deprecated Scope will be made private for next major version
* - use get/setLongOptPrefix methods instead.
*/
@Deprecated
public String defaultLongOptPrefix = DEFAULT_LONG_OPT_PREFIX;
/**
* the name of the argument
*
* @deprecated Scope will be made private for next major version
* - use get/setArgName methods instead.
*/
@Deprecated
public String defaultArgName = DEFAULT_ARG_NAME;
/**
* Comparator used to sort the options when they output in help text
*
* Defaults to case-insensitive alphabetical sorting by option key
*/
protected Comparator optionComparator = new OptionComparator();
/** The separator displayed between the long option and its value. */
private String longOptSeparator = DEFAULT_LONG_OPT_SEPARATOR;
/**
* Sets the 'width'.
*
* @param width the new value of 'width'
*/
public void setWidth(int width)
{
this.defaultWidth = width;
}
/**
* Returns the 'width'.
*
* @return the 'width'
*/
public int getWidth()
{
return defaultWidth;
}
/**
* Sets the 'leftPadding'.
*
* @param padding the new value of 'leftPadding'
*/
public void setLeftPadding(int padding)
{
this.defaultLeftPad = padding;
}
/**
* Returns the 'leftPadding'.
*
* @return the 'leftPadding'
*/
public int getLeftPadding()
{
return defaultLeftPad;
}
/**
* Sets the 'descPadding'.
*
* @param padding the new value of 'descPadding'
*/
public void setDescPadding(int padding)
{
this.defaultDescPad = padding;
}
/**
* Returns the 'descPadding'.
*
* @return the 'descPadding'
*/
public int getDescPadding()
{
return defaultDescPad;
}
/**
* Sets the 'syntaxPrefix'.
*
* @param prefix the new value of 'syntaxPrefix'
*/
public void setSyntaxPrefix(String prefix)
{
this.defaultSyntaxPrefix = prefix;
}
/**
* Returns the 'syntaxPrefix'.
*
* @return the 'syntaxPrefix'
*/
public String getSyntaxPrefix()
{
return defaultSyntaxPrefix;
}
/**
* Sets the 'newLine'.
*
* @param newline the new value of 'newLine'
*/
public void setNewLine(String newline)
{
this.defaultNewLine = newline;
}
/**
* Returns the 'newLine'.
*
* @return the 'newLine'
*/
public String getNewLine()
{
return defaultNewLine;
}
/**
* Sets the 'optPrefix'.
*
* @param prefix the new value of 'optPrefix'
*/
public void setOptPrefix(String prefix)
{
this.defaultOptPrefix = prefix;
}
/**
* Returns the 'optPrefix'.
*
* @return the 'optPrefix'
*/
public String getOptPrefix()
{
return defaultOptPrefix;
}
/**
* Sets the 'longOptPrefix'.
*
* @param prefix the new value of 'longOptPrefix'
*/
public void setLongOptPrefix(String prefix)
{
this.defaultLongOptPrefix = prefix;
}
/**
* Returns the 'longOptPrefix'.
*
* @return the 'longOptPrefix'
*/
public String getLongOptPrefix()
{
return defaultLongOptPrefix;
}
/**
* Set the separator displayed between a long option and its value.
* Ensure that the separator specified is supported by the parser used,
* typically ' ' or '='.
*
* @param longOptSeparator the separator, typically ' ' or '='.
* @since 1.3
*/
public void setLongOptSeparator(String longOptSeparator)
{
this.longOptSeparator = longOptSeparator;
}
/**
* Returns the separator displayed between a long option and its value.
*
* @return the separator
* @since 1.3
*/
public String getLongOptSeparator()
{
return longOptSeparator;
}
/**
* Sets the 'argName'.
*
* @param name the new value of 'argName'
*/
public void setArgName(String name)
{
this.defaultArgName = name;
}
/**
* Returns the 'argName'.
*
* @return the 'argName'
*/
public String getArgName()
{
return defaultArgName;
}
/**
* Comparator used to sort the options when they output in help text.
* Defaults to case-insensitive alphabetical sorting by option key.
*
* @return the {@link Comparator} currently in use to sort the options
* @since 1.2
*/
public Comparator getOptionComparator()
{
return optionComparator;
}
/**
* Set the comparator used to sort the options when they output in help text.
* Passing in a null comparator will keep the options in the order they were declared.
*
* @param comparator the {@link Comparator} to use for sorting the options
* @since 1.2
*/
public void setOptionComparator(Comparator comparator)
{
this.optionComparator = comparator;
}
/**
* Print the help for options with the specified
* command line syntax. This method prints help information to
* System.out.
*
* @param cmdLineSyntax the syntax for this application
* @param options the Options instance
*/
public void printHelp(String cmdLineSyntax, Options options)
{
printHelp(getWidth(), cmdLineSyntax, null, options, null, false);
}
/**
* Print the help for options with the specified
* command line syntax. This method prints help information to
* System.out.
*
* @param cmdLineSyntax the syntax for this application
* @param options the Options instance
* @param autoUsage whether to print an automatically generated
* usage statement
*/
public void printHelp(String cmdLineSyntax, Options options, boolean autoUsage)
{
printHelp(getWidth(), cmdLineSyntax, null, options, null, autoUsage);
}
/**
* Print the help for options with the specified
* command line syntax. This method prints help information to
* System.out.
*
* @param cmdLineSyntax the syntax for this application
* @param header the banner to display at the beginning of the help
* @param options the Options instance
* @param footer the banner to display at the end of the help
*/
public void printHelp(String cmdLineSyntax, String header, Options options, String footer)
{
printHelp(cmdLineSyntax, header, options, footer, false);
}
/**
* Print the help for options with the specified
* command line syntax. This method prints help information to
* System.out.
*
* @param cmdLineSyntax the syntax for this application
* @param header the banner to display at the beginning of the help
* @param options the Options instance
* @param footer the banner to display at the end of the help
* @param autoUsage whether to print an automatically generated
* usage statement
*/
public void printHelp(String cmdLineSyntax, String header, Options options, String footer, boolean autoUsage)
{
printHelp(getWidth(), cmdLineSyntax, header, options, footer, autoUsage);
}
/**
* Print the help for options with the specified
* command line syntax. This method prints help information to
* System.out.
*
* @param width the number of characters to be displayed on each line
* @param cmdLineSyntax the syntax for this application
* @param header the banner to display at the beginning of the help
* @param options the Options instance
* @param footer the banner to display at the end of the help
*/
public void printHelp(int width, String cmdLineSyntax, String header, Options options, String footer)
{
printHelp(width, cmdLineSyntax, header, options, footer, false);
}
/**
* Print the help for options with the specified
* command line syntax. This method prints help information to
* System.out.
*
* @param width the number of characters to be displayed on each line
* @param cmdLineSyntax the syntax for this application
* @param header the banner to display at the beginning of the help
* @param options the Options instance
* @param footer the banner to display at the end of the help
* @param autoUsage whether to print an automatically generated
* usage statement
*/
public void printHelp(int width, String cmdLineSyntax, String header,
Options options, String footer, boolean autoUsage)
{
PrintWriter pw = new PrintWriter(System.out);
printHelp(pw, width, cmdLineSyntax, header, options, getLeftPadding(), getDescPadding(), footer, autoUsage);
pw.flush();
}
/**
* Print the help for options with the specified
* command line syntax.
*
* @param pw the writer to which the help will be written
* @param width the number of characters to be displayed on each line
* @param cmdLineSyntax the syntax for this application
* @param header the banner to display at the beginning of the help
* @param options the Options instance
* @param leftPad the number of characters of padding to be prefixed
* to each line
* @param descPad the number of characters of padding to be prefixed
* to each description line
* @param footer the banner to display at the end of the help
*
* @throws IllegalStateException if there is no room to print a line
*/
public void printHelp(PrintWriter pw, int width, String cmdLineSyntax,
String header, Options options, int leftPad,
int descPad, String footer)
{
printHelp(pw, width, cmdLineSyntax, header, options, leftPad, descPad, footer, false);
}
/**
* Print the help for options with the specified
* command line syntax.
*
* @param pw the writer to which the help will be written
* @param width the number of characters to be displayed on each line
* @param cmdLineSyntax the syntax for this application
* @param header the banner to display at the beginning of the help
* @param options the Options instance
* @param leftPad the number of characters of padding to be prefixed
* to each line
* @param descPad the number of characters of padding to be prefixed
* to each description line
* @param footer the banner to display at the end of the help
* @param autoUsage whether to print an automatically generated
* usage statement
*
* @throws IllegalStateException if there is no room to print a line
*/
public void printHelp(PrintWriter pw, int width, String cmdLineSyntax,
String header, Options options, int leftPad,
int descPad, String footer, boolean autoUsage)
{
if (cmdLineSyntax == null || cmdLineSyntax.length() == 0)
{
throw new IllegalArgumentException("cmdLineSyntax not provided");
}
if (autoUsage)
{
printUsage(pw, width, cmdLineSyntax, options);
}
else
{
printUsage(pw, width, cmdLineSyntax);
}
if (header != null && header.trim().length() > 0)
{
printWrapped(pw, width, header);
}
printOptions(pw, width, options, leftPad, descPad);
if (footer != null && footer.trim().length() > 0)
{
printWrapped(pw, width, footer);
}
}
/**
* Prints the usage statement for the specified application.
*
* @param pw The PrintWriter to print the usage statement
* @param width The number of characters to display per line
* @param app The application name
* @param options The command line Options
*/
public void printUsage(PrintWriter pw, int width, String app, Options options)
{
// initialise the string buffer
StringBuffer buff = new StringBuffer(getSyntaxPrefix()).append(app).append(" ");
// create a list for processed option groups
Collection processedGroups = new ArrayList();
List optList = new ArrayList (options.getOptions());
if (getOptionComparator() != null)
{
Collections.sort(optList, getOptionComparator());
}
// iterate over the options
for (Iterator it = optList.iterator(); it.hasNext();)
{
// get the next Option
Option option = it.next();
// check if the option is part of an OptionGroup
OptionGroup group = options.getOptionGroup(option);
// if the option is part of a group
if (group != null)
{
// and if the group has not already been processed
if (!processedGroups.contains(group))
{
// add the group to the processed list
processedGroups.add(group);
// add the usage clause
appendOptionGroup(buff, group);
}
// otherwise the option was displayed in the group
// previously so ignore it.
}
// if the Option is not part of an OptionGroup
else
{
appendOption(buff, option, option.isRequired());
}
if (it.hasNext())
{
buff.append(" ");
}
}
// call printWrapped
printWrapped(pw, width, buff.toString().indexOf(' ') + 1, buff.toString());
}
/**
* Appends the usage clause for an OptionGroup to a StringBuffer.
* The clause is wrapped in square brackets if the group is required.
* The display of the options is handled by appendOption
* @param buff the StringBuffer to append to
* @param group the group to append
* @see #appendOption(StringBuffer,Option,boolean)
*/
private void appendOptionGroup(StringBuffer buff, OptionGroup group)
{
if (!group.isRequired())
{
buff.append("[");
}
List optList = new ArrayList (group.getOptions());
if (getOptionComparator() != null)
{
Collections.sort(optList, getOptionComparator());
}
// for each option in the OptionGroup
for (Iterator it = optList.iterator(); it.hasNext();)
{
// whether the option is required or not is handled at group level
appendOption(buff, it.next(), true);
if (it.hasNext())
{
buff.append(" | ");
}
}
if (!group.isRequired())
{
buff.append("]");
}
}
/**
* Appends the usage clause for an Option to a StringBuffer.
*
* @param buff the StringBuffer to append to
* @param option the Option to append
* @param required whether the Option is required or not
*/
private void appendOption(StringBuffer buff, Option option, boolean required)
{
if (!required)
{
buff.append("[");
}
if (option.getOpt() != null)
{
buff.append("-").append(option.getOpt());
}
else
{
buff.append("--").append(option.getLongOpt());
}
// if the Option has a value and a non blank argname
if (option.hasArg() && (option.getArgName() == null || option.getArgName().length() != 0))
{
buff.append(option.getOpt() == null ? longOptSeparator : " ");
buff.append("<").append(option.getArgName() != null ? option.getArgName() : getArgName()).append(">");
}
// if the Option is not a required option
if (!required)
{
buff.append("]");
}
}
/**
* Print the cmdLineSyntax to the specified writer, using the
* specified width.
*
* @param pw The printWriter to write the help to
* @param width The number of characters per line for the usage statement.
* @param cmdLineSyntax The usage statement.
*/
public void printUsage(PrintWriter pw, int width, String cmdLineSyntax)
{
int argPos = cmdLineSyntax.indexOf(' ') + 1;
printWrapped(pw, width, getSyntaxPrefix().length() + argPos, getSyntaxPrefix() + cmdLineSyntax);
}
/**
* Print the help for the specified Options to the specified writer,
* using the specified width, left padding and description padding.
*
* @param pw The printWriter to write the help to
* @param width The number of characters to display per line
* @param options The command line Options
* @param leftPad the number of characters of padding to be prefixed
* to each line
* @param descPad the number of characters of padding to be prefixed
* to each description line
*/
public void printOptions(PrintWriter pw, int width, Options options,
int leftPad, int descPad)
{
StringBuffer sb = new StringBuffer();
renderOptions(sb, width, options, leftPad, descPad);
pw.println(sb.toString());
}
/**
* Print the specified text to the specified PrintWriter.
*
* @param pw The printWriter to write the help to
* @param width The number of characters to display per line
* @param text The text to be written to the PrintWriter
*/
public void printWrapped(PrintWriter pw, int width, String text)
{
printWrapped(pw, width, 0, text);
}
/**
* Print the specified text to the specified PrintWriter.
*
* @param pw The printWriter to write the help to
* @param width The number of characters to display per line
* @param nextLineTabStop The position on the next line for the first tab.
* @param text The text to be written to the PrintWriter
*/
public void printWrapped(PrintWriter pw, int width, int nextLineTabStop, String text)
{
StringBuffer sb = new StringBuffer(text.length());
renderWrappedTextBlock(sb, width, nextLineTabStop, text);
pw.println(sb.toString());
}
// --------------------------------------------------------------- Protected
/**
* Render the specified Options and return the rendered Options
* in a StringBuffer.
*
* @param sb The StringBuffer to place the rendered Options into.
* @param width The number of characters to display per line
* @param options The command line Options
* @param leftPad the number of characters of padding to be prefixed
* to each line
* @param descPad the number of characters of padding to be prefixed
* to each description line
*
* @return the StringBuffer with the rendered Options contents.
*/
protected StringBuffer renderOptions(StringBuffer sb, int width, Options options, int leftPad, int descPad)
{
final String lpad = createPadding(leftPad);
final String dpad = createPadding(descPad);
// first create list containing only -a,--aaa where
// -a is opt and --aaa is long opt; in parallel look for
// the longest opt string this list will be then used to
// sort options ascending
int max = 0;
List prefixList = new ArrayList();
List optList = options.helpOptions();
if (getOptionComparator() != null)
{
Collections.sort(optList, getOptionComparator());
}
for (Option option : optList)
{
StringBuffer optBuf = new StringBuffer();
if (option.getOpt() == null)
{
optBuf.append(lpad).append(" ").append(getLongOptPrefix()).append(option.getLongOpt());
}
else
{
optBuf.append(lpad).append(getOptPrefix()).append(option.getOpt());
if (option.hasLongOpt())
{
optBuf.append(',').append(getLongOptPrefix()).append(option.getLongOpt());
}
}
if (option.hasArg())
{
String argName = option.getArgName();
if (argName != null && argName.length() == 0)
{
// if the option has a blank argname
optBuf.append(' ');
}
else
{
optBuf.append(option.hasLongOpt() ? longOptSeparator : " ");
optBuf.append("<").append(argName != null ? option.getArgName() : getArgName()).append(">");
}
}
prefixList.add(optBuf);
max = optBuf.length() > max ? optBuf.length() : max;
}
int x = 0;
for (Iterator it = optList.iterator(); it.hasNext();)
{
Option option = it.next();
StringBuilder optBuf = new StringBuilder(prefixList.get(x++).toString());
if (optBuf.length() < max)
{
optBuf.append(createPadding(max - optBuf.length()));
}
optBuf.append(dpad);
int nextLineTabStop = max + descPad;
if (option.getDescription() != null)
{
optBuf.append(option.getDescription());
}
renderWrappedText(sb, width, nextLineTabStop, optBuf.toString());
if (it.hasNext())
{
sb.append(getNewLine());
}
}
return sb;
}
/**
* Render the specified text and return the rendered Options
* in a StringBuffer.
*
* @param sb The StringBuffer to place the rendered text into.
* @param width The number of characters to display per line
* @param nextLineTabStop The position on the next line for the first tab.
* @param text The text to be rendered.
*
* @return the StringBuffer with the rendered Options contents.
*/
protected StringBuffer renderWrappedText(StringBuffer sb, int width,
int nextLineTabStop, String text)
{
int pos = findWrapPos(text, width, 0);
if (pos == -1)
{
sb.append(rtrim(text));
return sb;
}
sb.append(rtrim(text.substring(0, pos))).append(getNewLine());
if (nextLineTabStop >= width)
{
// stops infinite loop happening
nextLineTabStop = 1;
}
// all following lines must be padded with nextLineTabStop space characters
final String padding = createPadding(nextLineTabStop);
while (true)
{
text = padding + text.substring(pos).trim();
pos = findWrapPos(text, width, 0);
if (pos == -1)
{
sb.append(text);
return sb;
}
if (text.length() > width && pos == nextLineTabStop - 1)
{
pos = width;
}
sb.append(rtrim(text.substring(0, pos))).append(getNewLine());
}
}
/**
* Render the specified text width a maximum width. This method differs
* from renderWrappedText by not removing leading spaces after a new line.
*
* @param sb The StringBuffer to place the rendered text into.
* @param width The number of characters to display per line
* @param nextLineTabStop The position on the next line for the first tab.
* @param text The text to be rendered.
*/
private Appendable renderWrappedTextBlock(StringBuffer sb, int width, int nextLineTabStop, String text)
{
try
{
BufferedReader in = new BufferedReader(new StringReader(text));
String line;
boolean firstLine = true;
while ((line = in.readLine()) != null)
{
if (!firstLine)
{
sb.append(getNewLine());
}
else
{
firstLine = false;
}
renderWrappedText(sb, width, nextLineTabStop, line);
}
}
catch (IOException e) //NOPMD
{
// cannot happen
}
return sb;
}
/**
* Finds the next text wrap position after startPos for the
* text in text with the column width width.
* The wrap point is the last position before startPos+width having a
* whitespace character (space, \n, \r). If there is no whitespace character
* before startPos+width, it will return startPos+width.
*
* @param text The text being searched for the wrap position
* @param width width of the wrapped text
* @param startPos position from which to start the lookup whitespace
* character
* @return position on which the text must be wrapped or -1 if the wrap
* position is at the end of the text
*/
protected int findWrapPos(String text, int width, int startPos)
{
// the line ends before the max wrap pos or a new line char found
int pos = text.indexOf('\n', startPos);
if (pos != -1 && pos <= width)
{
return pos + 1;
}
pos = text.indexOf('\t', startPos);
if (pos != -1 && pos <= width)
{
return pos + 1;
}
if (startPos + width >= text.length())
{
return -1;
}
// look for the last whitespace character before startPos+width
for (pos = startPos + width; pos >= startPos; --pos)
{
final char c = text.charAt(pos);
if (c == ' ' || c == '\n' || c == '\r')
{
break;
}
}
// if we found it - just return
if (pos > startPos)
{
return pos;
}
// if we didn't find one, simply chop at startPos+width
pos = startPos + width;
return pos == text.length() ? -1 : pos;
}
/**
* Return a String of padding of length len.
*
* @param len The length of the String of padding to create.
*
* @return The String of padding
*/
protected String createPadding(int len)
{
char[] padding = new char[len];
Arrays.fill(padding, ' ');
return new String(padding);
}
/**
* Remove the trailing whitespace from the specified String.
*
* @param s The String to remove the trailing padding from.
*
* @return The String of without the trailing padding
*/
protected String rtrim(String s)
{
if (s == null || s.length() == 0)
{
return s;
}
int pos = s.length();
while (pos > 0 && Character.isWhitespace(s.charAt(pos - 1)))
{
--pos;
}
return s.substring(0, pos);
}
// ------------------------------------------------------ Package protected
// ---------------------------------------------------------------- Private
// ---------------------------------------------------------- Inner classes
/**
* This class implements the Comparator interface
* for comparing Options.
*/
private static class OptionComparator implements Comparator , Serializable
{
/** The serial version UID. */
private static final long serialVersionUID = 5305467873966684014L;
/**
* Compares its two arguments for order. Returns a negative
* integer, zero, or a positive integer as the first argument
* is less than, equal to, or greater than the second.
*
* @param opt1 The first Option to be compared.
* @param opt2 The second Option to be compared.
* @return a negative integer, zero, or a positive integer as
* the first argument is less than, equal to, or greater than the
* second.
*/
public int compare(Option opt1, Option opt2)
{
return opt1.getKey().compareToIgnoreCase(opt2.getKey());
}
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/MissingArgumentException.java 0100644 0000765 0000024 00000004141 12537250704 031707 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
/**
* Thrown when an option requiring an argument
* is not provided with an argument.
*
* @version $Id: MissingArgumentException.java 1443102 2013-02-06 18:12:16Z tn $
*/
public class MissingArgumentException extends ParseException
{
/**
* This exception {@code serialVersionUID}.
*/
private static final long serialVersionUID = -7098538588704965017L;
/** The option requiring additional arguments */
private Option option;
/**
* Construct a new MissingArgumentException
* with the specified detail message.
*
* @param message the detail message
*/
public MissingArgumentException(String message)
{
super(message);
}
/**
* Construct a new MissingArgumentException
* with the specified detail message.
*
* @param option the option requiring an argument
* @since 1.2
*/
public MissingArgumentException(Option option)
{
this("Missing argument for option: " + option.getKey());
this.option = option;
}
/**
* Return the option requiring an argument that wasn't provided
* on the command line.
*
* @return the related option
* @since 1.2
*/
public Option getOption()
{
return option;
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/MissingOptionException.java 0100644 0000765 0000024 00000005645 12537250704 031407 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.util.List;
import java.util.Iterator;
/**
* Thrown when a required option has not been provided.
*
* @version $Id: MissingOptionException.java 1443102 2013-02-06 18:12:16Z tn $
*/
public class MissingOptionException extends ParseException
{
/** This exception {@code serialVersionUID}. */
private static final long serialVersionUID = 8161889051578563249L;
/** The list of missing options and groups */
private List missingOptions;
/**
* Construct a new MissingSelectedException
* with the specified detail message.
*
* @param message the detail message
*/
public MissingOptionException(String message)
{
super(message);
}
/**
* Constructs a new MissingSelectedException with the
* specified list of missing options.
*
* @param missingOptions the list of missing options and groups
* @since 1.2
*/
public MissingOptionException(List missingOptions)
{
this(createMessage(missingOptions));
this.missingOptions = missingOptions;
}
/**
* Returns the list of options or option groups missing in the command line parsed.
*
* @return the missing options, consisting of String instances for simple
* options, and OptionGroup instances for required option groups.
* @since 1.2
*/
public List getMissingOptions()
{
return missingOptions;
}
/**
* Build the exception message from the specified list of options.
*
* @param missingOptions the list of missing options and groups
* @since 1.2
*/
private static String createMessage(List missingOptions)
{
StringBuilder buf = new StringBuilder("Missing required option");
buf.append(missingOptions.size() == 1 ? "" : "s");
buf.append(": ");
Iterator it = missingOptions.iterator();
while (it.hasNext())
{
buf.append(it.next());
if (it.hasNext())
{
buf.append(", ");
}
}
return buf.toString();
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/Option.java 0100644 0000765 0000024 00000066524 12537250704 026201 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
* Describes a single command-line option. It maintains
* information regarding the short-name of the option, the long-name,
* if any exists, a flag indicating if an argument is required for
* this option, and a self-documenting description of the option.
*
* An Option is not created independently, but is created through
* an instance of {@link Options}. An Option is required to have
* at least a short or a long-name.
*
* Note: once an {@link Option} has been added to an instance
* of {@link Options}, it's required flag may not be changed anymore.
*
* @see org.apache.commons.cli.Options
* @see org.apache.commons.cli.CommandLine
*
* @version $Id: Option.java 1677406 2015-05-03 14:27:31Z britter $
*/
public class Option implements Cloneable, Serializable
{
/** constant that specifies the number of argument values has not been specified */
public static final int UNINITIALIZED = -1;
/** constant that specifies the number of argument values is infinite */
public static final int UNLIMITED_VALUES = -2;
/** The serial version UID. */
private static final long serialVersionUID = 1L;
/** the name of the option */
private final String opt;
/** the long representation of the option */
private String longOpt;
/** the name of the argument for this option */
private String argName;
/** description of the option */
private String description;
/** specifies whether this option is required to be present */
private boolean required;
/** specifies whether the argument value of this Option is optional */
private boolean optionalArg;
/** the number of argument values this option can have */
private int numberOfArgs = UNINITIALIZED;
/** the type of this Option */
private Class type = String.class;
/** the list of argument values **/
private List values = new ArrayList();
/** the character that is the value separator */
private char valuesep;
/**
* Private constructor used by the nested Builder class.
*
* @param builder builder used to create this option
*/
private Option(final Builder builder)
{
this.argName = builder.argName;
this.description = builder.description;
this.longOpt = builder.longOpt;
this.numberOfArgs = builder.numberOfArgs;
this.opt = builder.opt;
this.optionalArg = builder.optionalArg;
this.required = builder.required;
this.type = builder.type;
this.valuesep = builder.valuesep;
}
/**
* Creates an Option using the specified parameters.
* The option does not take an argument.
*
* @param opt short representation of the option
* @param description describes the function of the option
*
* @throws IllegalArgumentException if there are any non valid
* Option characters in opt.
*/
public Option(String opt, String description) throws IllegalArgumentException
{
this(opt, null, false, description);
}
/**
* Creates an Option using the specified parameters.
*
* @param opt short representation of the option
* @param hasArg specifies whether the Option takes an argument or not
* @param description describes the function of the option
*
* @throws IllegalArgumentException if there are any non valid
* Option characters in opt.
*/
public Option(String opt, boolean hasArg, String description) throws IllegalArgumentException
{
this(opt, null, hasArg, description);
}
/**
* Creates an Option using the specified parameters.
*
* @param opt short representation of the option
* @param longOpt the long representation of the option
* @param hasArg specifies whether the Option takes an argument or not
* @param description describes the function of the option
*
* @throws IllegalArgumentException if there are any non valid
* Option characters in opt.
*/
public Option(String opt, String longOpt, boolean hasArg, String description)
throws IllegalArgumentException
{
// ensure that the option is valid
OptionValidator.validateOption(opt);
this.opt = opt;
this.longOpt = longOpt;
// if hasArg is set then the number of arguments is 1
if (hasArg)
{
this.numberOfArgs = 1;
}
this.description = description;
}
/**
* Returns the id of this Option. This is only set when the
* Option shortOpt is a single character. This is used for switch
* statements.
*
* @return the id of this Option
*/
public int getId()
{
return getKey().charAt(0);
}
/**
* Returns the 'unique' Option identifier.
*
* @return the 'unique' Option identifier
*/
String getKey()
{
// if 'opt' is null, then it is a 'long' option
return (opt == null) ? longOpt : opt;
}
/**
* Retrieve the name of this Option.
*
* It is this String which can be used with
* {@link CommandLine#hasOption(String opt)} and
* {@link CommandLine#getOptionValue(String opt)} to check
* for existence and argument.
*
* @return The name of this option
*/
public String getOpt()
{
return opt;
}
/**
* Retrieve the type of this Option.
*
* @return The type of this option
*/
public Object getType()
{
return type;
}
/**
* Sets the type of this Option.
*
* Note: this method is kept for binary compatibility and the
* input type is supposed to be a {@link Class} object.
*
* @param type the type of this Option
* @deprecated since 1.3, use {@link #setType(Class)} instead
*/
@Deprecated
public void setType(Object type)
{
setType((Class) type);
}
/**
* Sets the type of this Option.
*
* @param type the type of this Option
* @since 1.3
*/
public void setType(Class type)
{
this.type = type;
}
/**
* Retrieve the long name of this Option.
*
* @return Long name of this option, or null, if there is no long name
*/
public String getLongOpt()
{
return longOpt;
}
/**
* Sets the long name of this Option.
*
* @param longOpt the long name of this Option
*/
public void setLongOpt(String longOpt)
{
this.longOpt = longOpt;
}
/**
* Sets whether this Option can have an optional argument.
*
* @param optionalArg specifies whether the Option can have
* an optional argument.
*/
public void setOptionalArg(boolean optionalArg)
{
this.optionalArg = optionalArg;
}
/**
* @return whether this Option can have an optional argument
*/
public boolean hasOptionalArg()
{
return optionalArg;
}
/**
* Query to see if this Option has a long name
*
* @return boolean flag indicating existence of a long name
*/
public boolean hasLongOpt()
{
return longOpt != null;
}
/**
* Query to see if this Option requires an argument
*
* @return boolean flag indicating if an argument is required
*/
public boolean hasArg()
{
return numberOfArgs > 0 || numberOfArgs == UNLIMITED_VALUES;
}
/**
* Retrieve the self-documenting description of this Option
*
* @return The string description of this option
*/
public String getDescription()
{
return description;
}
/**
* Sets the self-documenting description of this Option
*
* @param description The description of this option
* @since 1.1
*/
public void setDescription(String description)
{
this.description = description;
}
/**
* Query to see if this Option is mandatory
*
* @return boolean flag indicating whether this Option is mandatory
*/
public boolean isRequired()
{
return required;
}
/**
* Sets whether this Option is mandatory.
*
* @param required specifies whether this Option is mandatory
*/
public void setRequired(boolean required)
{
this.required = required;
}
/**
* Sets the display name for the argument value.
*
* @param argName the display name for the argument value.
*/
public void setArgName(String argName)
{
this.argName = argName;
}
/**
* Gets the display name for the argument value.
*
* @return the display name for the argument value.
*/
public String getArgName()
{
return argName;
}
/**
* Returns whether the display name for the argument value has been set.
*
* @return if the display name for the argument value has been set.
*/
public boolean hasArgName()
{
return argName != null && argName.length() > 0;
}
/**
* Query to see if this Option can take many values.
*
* @return boolean flag indicating if multiple values are allowed
*/
public boolean hasArgs()
{
return numberOfArgs > 1 || numberOfArgs == UNLIMITED_VALUES;
}
/**
* Sets the number of argument values this Option can take.
*
* @param num the number of argument values
*/
public void setArgs(int num)
{
this.numberOfArgs = num;
}
/**
* Sets the value separator. For example if the argument value
* was a Java property, the value separator would be '='.
*
* @param sep The value separator.
*/
public void setValueSeparator(char sep)
{
this.valuesep = sep;
}
/**
* Returns the value separator character.
*
* @return the value separator character.
*/
public char getValueSeparator()
{
return valuesep;
}
/**
* Return whether this Option has specified a value separator.
*
* @return whether this Option has specified a value separator.
* @since 1.1
*/
public boolean hasValueSeparator()
{
return valuesep > 0;
}
/**
* Returns the number of argument values this Option can take.
*
* @return num the number of argument values
*/
public int getArgs()
{
return numberOfArgs;
}
/**
* Adds the specified value to this Option.
*
* @param value is a/the value of this Option
*/
void addValueForProcessing(String value)
{
if (numberOfArgs == UNINITIALIZED)
{
throw new RuntimeException("NO_ARGS_ALLOWED");
}
processValue(value);
}
/**
* Processes the value. If this Option has a value separator
* the value will have to be parsed into individual tokens. When
* n-1 tokens have been processed and there are more value separators
* in the value, parsing is ceased and the remaining characters are
* added as a single token.
*
* @param value The String to be processed.
*
* @since 1.0.1
*/
private void processValue(String value)
{
// this Option has a separator character
if (hasValueSeparator())
{
// get the separator character
char sep = getValueSeparator();
// store the index for the value separator
int index = value.indexOf(sep);
// while there are more value separators
while (index != -1)
{
// next value to be added
if (values.size() == numberOfArgs - 1)
{
break;
}
// store
add(value.substring(0, index));
// parse
value = value.substring(index + 1);
// get new index
index = value.indexOf(sep);
}
}
// store the actual value or the last value that has been parsed
add(value);
}
/**
* Add the value to this Option. If the number of arguments
* is greater than zero and there is enough space in the list then
* add the value. Otherwise, throw a runtime exception.
*
* @param value The value to be added to this Option
*
* @since 1.0.1
*/
private void add(String value)
{
if (!acceptsArg())
{
throw new RuntimeException("Cannot add value, list full.");
}
// store value
values.add(value);
}
/**
* Returns the specified value of this Option or
* null if there is no value.
*
* @return the value/first value of this Option or
* null if there is no value.
*/
public String getValue()
{
return hasNoValues() ? null : values.get(0);
}
/**
* Returns the specified value of this Option or
* null if there is no value.
*
* @param index The index of the value to be returned.
*
* @return the specified value of this Option or
* null if there is no value.
*
* @throws IndexOutOfBoundsException if index is less than 1
* or greater than the number of the values for this Option.
*/
public String getValue(int index) throws IndexOutOfBoundsException
{
return hasNoValues() ? null : values.get(index);
}
/**
* Returns the value/first value of this Option or the
* defaultValue if there is no value.
*
* @param defaultValue The value to be returned if there
* is no value.
*
* @return the value/first value of this Option or the
* defaultValue if there are no values.
*/
public String getValue(String defaultValue)
{
String value = getValue();
return (value != null) ? value : defaultValue;
}
/**
* Return the values of this Option as a String array
* or null if there are no values
*
* @return the values of this Option as a String array
* or null if there are no values
*/
public String[] getValues()
{
return hasNoValues() ? null : values.toArray(new String[values.size()]);
}
/**
* @return the values of this Option as a List
* or null if there are no values
*/
public List getValuesList()
{
return values;
}
/**
* Dump state, suitable for debugging.
*
* @return Stringified form of this object
*/
@Override
public String toString()
{
StringBuilder buf = new StringBuilder().append("[ option: ");
buf.append(opt);
if (longOpt != null)
{
buf.append(" ").append(longOpt);
}
buf.append(" ");
if (hasArgs())
{
buf.append("[ARG...]");
}
else if (hasArg())
{
buf.append(" [ARG]");
}
buf.append(" :: ").append(description);
if (type != null)
{
buf.append(" :: ").append(type);
}
buf.append(" ]");
return buf.toString();
}
/**
* Returns whether this Option has any values.
*
* @return whether this Option has any values.
*/
private boolean hasNoValues()
{
return values.isEmpty();
}
@Override
public boolean equals(Object o)
{
if (this == o)
{
return true;
}
if (o == null || getClass() != o.getClass())
{
return false;
}
Option option = (Option) o;
if (opt != null ? !opt.equals(option.opt) : option.opt != null)
{
return false;
}
if (longOpt != null ? !longOpt.equals(option.longOpt) : option.longOpt != null)
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result;
result = opt != null ? opt.hashCode() : 0;
result = 31 * result + (longOpt != null ? longOpt.hashCode() : 0);
return result;
}
/**
* A rather odd clone method - due to incorrect code in 1.0 it is public
* and in 1.1 rather than throwing a CloneNotSupportedException it throws
* a RuntimeException so as to maintain backwards compat at the API level.
*
* After calling this method, it is very likely you will want to call
* clearValues().
*
* @return a clone of this Option instance
* @throws RuntimeException if a {@link CloneNotSupportedException} has been thrown
* by {@code super.clone()}
*/
@Override
public Object clone()
{
try
{
Option option = (Option) super.clone();
option.values = new ArrayList(values);
return option;
}
catch (CloneNotSupportedException cnse)
{
throw new RuntimeException("A CloneNotSupportedException was thrown: " + cnse.getMessage());
}
}
/**
* Clear the Option values. After a parse is complete, these are left with
* data in them and they need clearing if another parse is done.
*
* See: CLI-71
*/
void clearValues()
{
values.clear();
}
/**
* This method is not intended to be used. It was a piece of internal
* API that was made public in 1.0. It currently throws an UnsupportedOperationException.
*
* @param value the value to add
* @return always throws an {@link UnsupportedOperationException}
* @throws UnsupportedOperationException always
* @deprecated
*/
@Deprecated
public boolean addValue(String value)
{
throw new UnsupportedOperationException("The addValue method is not intended for client use. "
+ "Subclasses should use the addValueForProcessing method instead. ");
}
/**
* Tells if the option can accept more arguments.
*
* @return false if the maximum number of arguments is reached
* @since 1.3
*/
boolean acceptsArg()
{
return (hasArg() || hasArgs() || hasOptionalArg()) && (numberOfArgs <= 0 || values.size() < numberOfArgs);
}
/**
* Tells if the option requires more arguments to be valid.
*
* @return false if the option doesn't require more arguments
* @since 1.3
*/
boolean requiresArg()
{
if (optionalArg)
{
return false;
}
if (numberOfArgs == UNLIMITED_VALUES)
{
return values.isEmpty();
}
return acceptsArg();
}
/**
* Returns a {@link Builder} to create an {@link Option} using descriptive
* methods.
*
* @return a new {@link Builder} instance
* @since 1.3
*/
public static Builder builder()
{
return builder(null);
}
/**
* Returns a {@link Builder} to create an {@link Option} using descriptive
* methods.
*
* @param opt short representation of the option
* @return a new {@link Builder} instance
* @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}
* @since 1.3
*/
public static Builder builder(final String opt)
{
return new Builder(opt);
}
/**
* A nested builder class to create Option instances
* using descriptive methods.
*
* Example usage:
*
* Option option = Option.builder("a")
* .required(true)
* .longOpt("arg-name")
* .build();
*
*
* @since 1.3
*/
public static final class Builder
{
/** the name of the option */
private final String opt;
/** description of the option */
private String description;
/** the long representation of the option */
private String longOpt;
/** the name of the argument for this option */
private String argName;
/** specifies whether this option is required to be present */
private boolean required;
/** specifies whether the argument value of this Option is optional */
private boolean optionalArg;
/** the number of argument values this option can have */
private int numberOfArgs = UNINITIALIZED;
/** the type of this Option */
private Class type = String.class;
/** the character that is the value separator */
private char valuesep;
/**
* Constructs a new Builder with the minimum
* required parameters for an Option instance.
*
* @param opt short representation of the option
* @throws IllegalArgumentException if there are any non valid Option characters in {@code opt}
*/
private Builder(final String opt) throws IllegalArgumentException
{
OptionValidator.validateOption(opt);
this.opt = opt;
}
/**
* Sets the display name for the argument value.
*
* @param argName the display name for the argument value.
* @return this builder, to allow method chaining
*/
public Builder argName(final String argName)
{
this.argName = argName;
return this;
}
/**
* Sets the description for this option.
*
* @param description the description of the option.
* @return this builder, to allow method chaining
*/
public Builder desc(final String description)
{
this.description = description;
return this;
}
/**
* Sets the long name of the Option.
*
* @param longOpt the long name of the Option
* @return this builder, to allow method chaining
*/
public Builder longOpt(final String longOpt)
{
this.longOpt = longOpt;
return this;
}
/**
* Sets the number of argument values the Option can take.
*
* @param numberOfArgs the number of argument values
* @return this builder, to allow method chaining
*/
public Builder numberOfArgs(final int numberOfArgs)
{
this.numberOfArgs = numberOfArgs;
return this;
}
/**
* Sets whether the Option can have an optional argument.
*
* @param isOptional specifies whether the Option can have
* an optional argument.
* @return this builder, to allow method chaining
*/
public Builder optionalArg(final boolean isOptional)
{
this.optionalArg = isOptional;
return this;
}
/**
* Marks this Option as required.
*
* @return this builder, to allow method chaining
*/
public Builder required()
{
return required(true);
}
/**
* Sets whether the Option is mandatory.
*
* @param required specifies whether the Option is mandatory
* @return this builder, to allow method chaining
*/
public Builder required(final boolean required)
{
this.required = required;
return this;
}
/**
* Sets the type of the Option.
*
* @param type the type of the Option
* @return this builder, to allow method chaining
*/
public Builder type(final Class type)
{
this.type = type;
return this;
}
/**
* The Option will use '=' as a means to separate argument value.
*
* @return this builder, to allow method chaining
*/
public Builder valueSeparator()
{
return valueSeparator('=');
}
/**
* The Option will use sep as a means to
* separate argument values.
*
* Example:
*
* Option opt = Option.builder("D").hasArgs()
* .valueSeparator('=')
* .build();
* Options options = new Options();
* options.addOption(opt);
* String[] args = {"-Dkey=value"};
* CommandLineParser parser = new DefaultParser();
* CommandLine line = parser.parse(options, args);
* String propertyName = line.getOptionValues("D")[0]; // will be "key"
* String propertyValue = line.getOptionValues("D")[1]; // will be "value"
*
*
* @param sep The value separator.
* @return this builder, to allow method chaining
*/
public Builder valueSeparator(final char sep)
{
valuesep = sep;
return this;
}
/**
* Indicates that the Option will require an argument.
*
* @return this builder, to allow method chaining
*/
public Builder hasArg()
{
return hasArg(true);
}
/**
* Indicates if the Option has an argument or not.
*
* @param hasArg specifies whether the Option takes an argument or not
* @return this builder, to allow method chaining
*/
public Builder hasArg(final boolean hasArg)
{
// set to UNINITIALIZED when no arg is specified to be compatible with OptionBuilder
numberOfArgs = hasArg ? 1 : Option.UNINITIALIZED;
return this;
}
/**
* Indicates that the Option can have unlimited argument values.
*
* @return this builder, to allow method chaining
*/
public Builder hasArgs()
{
numberOfArgs = Option.UNLIMITED_VALUES;
return this;
}
/**
* Constructs an Option with the values declared by this {@link Builder}.
*
* @return the new {@link Option}
* @throws IllegalArgumentException if neither {@code opt} or {@code longOpt} has been set
*/
public Option build()
{
if (opt == null && longOpt == null)
{
throw new IllegalArgumentException("Either opt or longOpt must be specified");
}
return new Option(this);
}
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/OptionBuilder.java 0100644 0000765 0000024 00000025350 12537250704 027500 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
/**
* OptionBuilder allows the user to create Options using descriptive methods.
*
* Details on the Builder pattern can be found at
* http://c2.com/cgi-bin/wiki?BuilderPattern .
*
* This class is NOT thread safe. See CLI-209
*
* @version $Id: OptionBuilder.java 1677400 2015-05-03 13:46:08Z britter $
* @since 1.0
* @deprecated since 1.3, use {@link Option#builder(String)} instead
*/
@Deprecated
public final class OptionBuilder
{
/** long option */
private static String longopt;
/** option description */
private static String description;
/** argument name */
private static String argName;
/** is required? */
private static boolean required;
/** the number of arguments */
private static int numberOfArgs = Option.UNINITIALIZED;
/** option type */
private static Class type;
/** option can have an optional argument value */
private static boolean optionalArg;
/** value separator for argument value */
private static char valuesep;
/** option builder instance */
private static final OptionBuilder INSTANCE = new OptionBuilder();
static
{
// ensure the consistency of the initial values
reset();
}
/**
* private constructor to prevent instances being created
*/
private OptionBuilder()
{
// hide the constructor
}
/**
* Resets the member variables to their default values.
*/
private static void reset()
{
description = null;
argName = null;
longopt = null;
type = String.class;
required = false;
numberOfArgs = Option.UNINITIALIZED;
optionalArg = false;
valuesep = (char) 0;
}
/**
* The next Option created will have the following long option value.
*
* @param newLongopt the long option value
* @return the OptionBuilder instance
*/
public static OptionBuilder withLongOpt(String newLongopt)
{
OptionBuilder.longopt = newLongopt;
return INSTANCE;
}
/**
* The next Option created will require an argument value.
*
* @return the OptionBuilder instance
*/
public static OptionBuilder hasArg()
{
OptionBuilder.numberOfArgs = 1;
return INSTANCE;
}
/**
* The next Option created will require an argument value if
* hasArg is true.
*
* @param hasArg if true then the Option has an argument value
* @return the OptionBuilder instance
*/
public static OptionBuilder hasArg(boolean hasArg)
{
OptionBuilder.numberOfArgs = hasArg ? 1 : Option.UNINITIALIZED;
return INSTANCE;
}
/**
* The next Option created will have the specified argument value name.
*
* @param name the name for the argument value
* @return the OptionBuilder instance
*/
public static OptionBuilder withArgName(String name)
{
OptionBuilder.argName = name;
return INSTANCE;
}
/**
* The next Option created will be required.
*
* @return the OptionBuilder instance
*/
public static OptionBuilder isRequired()
{
OptionBuilder.required = true;
return INSTANCE;
}
/**
* The next Option created uses sep as a means to
* separate argument values.
*
* Example:
*
* Option opt = OptionBuilder.withValueSeparator('=')
* .create('D');
*
* String args = "-Dkey=value";
* CommandLine line = parser.parse(args);
* String propertyName = opt.getValue(0); // will be "key"
* String propertyValue = opt.getValue(1); // will be "value"
*
*
* @param sep The value separator to be used for the argument values.
*
* @return the OptionBuilder instance
*/
public static OptionBuilder withValueSeparator(char sep)
{
OptionBuilder.valuesep = sep;
return INSTANCE;
}
/**
* The next Option created uses '=' as a means to
* separate argument values.
*
* Example:
*
* Option opt = OptionBuilder.withValueSeparator()
* .create('D');
*
* CommandLine line = parser.parse(args);
* String propertyName = opt.getValue(0);
* String propertyValue = opt.getValue(1);
*
*
* @return the OptionBuilder instance
*/
public static OptionBuilder withValueSeparator()
{
OptionBuilder.valuesep = '=';
return INSTANCE;
}
/**
* The next Option created will be required if required
* is true.
*
* @param newRequired if true then the Option is required
* @return the OptionBuilder instance
*/
public static OptionBuilder isRequired(boolean newRequired)
{
OptionBuilder.required = newRequired;
return INSTANCE;
}
/**
* The next Option created can have unlimited argument values.
*
* @return the OptionBuilder instance
*/
public static OptionBuilder hasArgs()
{
OptionBuilder.numberOfArgs = Option.UNLIMITED_VALUES;
return INSTANCE;
}
/**
* The next Option created can have num argument values.
*
* @param num the number of args that the option can have
* @return the OptionBuilder instance
*/
public static OptionBuilder hasArgs(int num)
{
OptionBuilder.numberOfArgs = num;
return INSTANCE;
}
/**
* The next Option can have an optional argument.
*
* @return the OptionBuilder instance
*/
public static OptionBuilder hasOptionalArg()
{
OptionBuilder.numberOfArgs = 1;
OptionBuilder.optionalArg = true;
return INSTANCE;
}
/**
* The next Option can have an unlimited number of optional arguments.
*
* @return the OptionBuilder instance
*/
public static OptionBuilder hasOptionalArgs()
{
OptionBuilder.numberOfArgs = Option.UNLIMITED_VALUES;
OptionBuilder.optionalArg = true;
return INSTANCE;
}
/**
* The next Option can have the specified number of optional arguments.
*
* @param numArgs - the maximum number of optional arguments
* the next Option created can have.
* @return the OptionBuilder instance
*/
public static OptionBuilder hasOptionalArgs(int numArgs)
{
OptionBuilder.numberOfArgs = numArgs;
OptionBuilder.optionalArg = true;
return INSTANCE;
}
/**
* The next Option created will have a value that will be an instance
* of type.
*
* Note: this method is kept for binary compatibility and the
* input type is supposed to be a {@link Class} object.
*
* @param newType the type of the Options argument value
* @return the OptionBuilder instance
* @deprecated since 1.3, use {@link #withType(Class)} instead
*/
@Deprecated
public static OptionBuilder withType(Object newType)
{
return withType((Class) newType);
}
/**
* The next Option created will have a value that will be an instance
* of type.
*
* @param newType the type of the Options argument value
* @return the OptionBuilder instance
* @since 1.3
*/
public static OptionBuilder withType(Class newType)
{
OptionBuilder.type = newType;
return INSTANCE;
}
/**
* The next Option created will have the specified description
*
* @param newDescription a description of the Option's purpose
* @return the OptionBuilder instance
*/
public static OptionBuilder withDescription(String newDescription)
{
OptionBuilder.description = newDescription;
return INSTANCE;
}
/**
* Create an Option using the current settings and with
* the specified Option char.
*
* @param opt the character representation of the Option
* @return the Option instance
* @throws IllegalArgumentException if opt is not
* a valid character. See Option.
*/
public static Option create(char opt) throws IllegalArgumentException
{
return create(String.valueOf(opt));
}
/**
* Create an Option using the current settings
*
* @return the Option instance
* @throws IllegalArgumentException if longOpt has not been set.
*/
public static Option create() throws IllegalArgumentException
{
if (longopt == null)
{
OptionBuilder.reset();
throw new IllegalArgumentException("must specify longopt");
}
return create(null);
}
/**
* Create an Option using the current settings and with
* the specified Option char.
*
* @param opt the java.lang.String representation
* of the Option
* @return the Option instance
* @throws IllegalArgumentException if opt is not
* a valid character. See Option.
*/
public static Option create(String opt) throws IllegalArgumentException
{
Option option = null;
try
{
// create the option
option = new Option(opt, description);
// set the option properties
option.setLongOpt(longopt);
option.setRequired(required);
option.setOptionalArg(optionalArg);
option.setArgs(numberOfArgs);
option.setType(type);
option.setValueSeparator(valuesep);
option.setArgName(argName);
}
finally
{
// reset the OptionBuilder properties
OptionBuilder.reset();
}
// return the Option instance
return option;
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/OptionGroup.java 0100644 0000765 0000024 00000011256 12537250704 027206 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.io.Serializable;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
* A group of mutually exclusive options.
*
* @version $Id: OptionGroup.java 1669814 2015-03-28 18:09:26Z britter $
*/
public class OptionGroup implements Serializable
{
/** The serial version UID. */
private static final long serialVersionUID = 1L;
/** hold the options */
private final Map optionMap = new HashMap();
/** the name of the selected option */
private String selected;
/** specified whether this group is required */
private boolean required;
/**
* Add the specified Option to this group.
*
* @param option the option to add to this group
* @return this option group with the option added
*/
public OptionGroup addOption(Option option)
{
// key - option name
// value - the option
optionMap.put(option.getKey(), option);
return this;
}
/**
* @return the names of the options in this group as a
* Collection
*/
public Collection getNames()
{
// the key set is the collection of names
return optionMap.keySet();
}
/**
* @return the options in this group as a Collection
*/
public Collection getOptions()
{
// the values are the collection of options
return optionMap.values();
}
/**
* Set the selected option of this group to name.
*
* @param option the option that is selected
* @throws AlreadySelectedException if an option from this group has
* already been selected.
*/
public void setSelected(Option option) throws AlreadySelectedException
{
if (option == null)
{
// reset the option previously selected
selected = null;
return;
}
// if no option has already been selected or the
// same option is being reselected then set the
// selected member variable
if (selected == null || selected.equals(option.getKey()))
{
selected = option.getKey();
}
else
{
throw new AlreadySelectedException(this, option);
}
}
/**
* @return the selected option name
*/
public String getSelected()
{
return selected;
}
/**
* @param required specifies if this group is required
*/
public void setRequired(boolean required)
{
this.required = required;
}
/**
* Returns whether this option group is required.
*
* @return whether this option group is required
*/
public boolean isRequired()
{
return required;
}
/**
* Returns the stringified version of this OptionGroup.
*
* @return the stringified representation of this group
*/
@Override
public String toString()
{
StringBuilder buff = new StringBuilder();
Iterator iter = getOptions().iterator();
buff.append("[");
while (iter.hasNext())
{
Option option = iter.next();
if (option.getOpt() != null)
{
buff.append("-");
buff.append(option.getOpt());
}
else
{
buff.append("--");
buff.append(option.getLongOpt());
}
if (option.getDescription() != null)
{
buff.append(" ");
buff.append(option.getDescription());
}
if (iter.hasNext())
{
buff.append(", ");
}
}
buff.append("]");
return buff.toString();
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/Options.java 0100644 0000765 0000024 00000023031 12537250704 026346 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Main entry-point into the library.
*
* Options represents a collection of {@link Option} objects, which
* describe the possible options for a command-line.
*
* It may flexibly parse long and short options, with or without
* values. Additionally, it may parse only a portion of a commandline,
* allowing for flexible multi-stage parsing.
*
* @see org.apache.commons.cli.CommandLine
*
* @version $Id: Options.java 1685376 2015-06-14 09:51:59Z britter $
*/
public class Options implements Serializable
{
/** The serial version UID. */
private static final long serialVersionUID = 1L;
/** a map of the options with the character key */
private final Map shortOpts = new LinkedHashMap();
/** a map of the options with the long key */
private final Map longOpts = new LinkedHashMap();
/** a map of the required options */
// N.B. This can contain either a String (addOption) or an OptionGroup (addOptionGroup)
// TODO this seems wrong
private final List requiredOpts = new ArrayList();
/** a map of the option groups */
private final Map optionGroups = new HashMap();
/**
* Add the specified option group.
*
* @param group the OptionGroup that is to be added
* @return the resulting Options instance
*/
public Options addOptionGroup(OptionGroup group)
{
if (group.isRequired())
{
requiredOpts.add(group);
}
for (Option option : group.getOptions())
{
// an Option cannot be required if it is in an
// OptionGroup, either the group is required or
// nothing is required
option.setRequired(false);
addOption(option);
optionGroups.put(option.getKey(), group);
}
return this;
}
/**
* Lists the OptionGroups that are members of this Options instance.
*
* @return a Collection of OptionGroup instances.
*/
Collection getOptionGroups()
{
return new HashSet(optionGroups.values());
}
/**
* Add an option that only contains a short name.
* The option does not take an argument.
*
* @param opt Short single-character name of the option.
* @param description Self-documenting description
* @return the resulting Options instance
* @since 1.3
*/
public Options addOption(String opt, String description)
{
addOption(opt, null, false, description);
return this;
}
/**
* Add an option that only contains a short-name.
* It may be specified as requiring an argument.
*
* @param opt Short single-character name of the option.
* @param hasArg flag signally if an argument is required after this option
* @param description Self-documenting description
* @return the resulting Options instance
*/
public Options addOption(String opt, boolean hasArg, String description)
{
addOption(opt, null, hasArg, description);
return this;
}
/**
* Add an option that contains a short-name and a long-name.
* It may be specified as requiring an argument.
*
* @param opt Short single-character name of the option.
* @param longOpt Long multi-character name of the option.
* @param hasArg flag signally if an argument is required after this option
* @param description Self-documenting description
* @return the resulting Options instance
*/
public Options addOption(String opt, String longOpt, boolean hasArg, String description)
{
addOption(new Option(opt, longOpt, hasArg, description));
return this;
}
/**
* Adds an option instance
*
* @param opt the option that is to be added
* @return the resulting Options instance
*/
public Options addOption(Option opt)
{
String key = opt.getKey();
// add it to the long option list
if (opt.hasLongOpt())
{
longOpts.put(opt.getLongOpt(), opt);
}
// if the option is required add it to the required list
if (opt.isRequired())
{
if (requiredOpts.contains(key))
{
requiredOpts.remove(requiredOpts.indexOf(key));
}
requiredOpts.add(key);
}
shortOpts.put(key, opt);
return this;
}
/**
* Retrieve a read-only list of options in this set
*
* @return read-only Collection of {@link Option} objects in this descriptor
*/
public Collection getOptions()
{
return Collections.unmodifiableCollection(helpOptions());
}
/**
* Returns the Options for use by the HelpFormatter.
*
* @return the List of Options
*/
List helpOptions()
{
return new ArrayList (shortOpts.values());
}
/**
* Returns the required options.
*
* @return read-only List of required options
*/
public List getRequiredOptions()
{
return Collections.unmodifiableList(requiredOpts);
}
/**
* Retrieve the {@link Option} matching the long or short name specified.
* The leading hyphens in the name are ignored (up to 2).
*
* @param opt short or long name of the {@link Option}
* @return the option represented by opt
*/
public Option getOption(String opt)
{
opt = Util.stripLeadingHyphens(opt);
if (shortOpts.containsKey(opt))
{
return shortOpts.get(opt);
}
return longOpts.get(opt);
}
/**
* Returns the options with a long name starting with the name specified.
*
* @param opt the partial name of the option
* @return the options matching the partial name specified, or an empty list if none matches
* @since 1.3
*/
public List getMatchingOptions(String opt)
{
opt = Util.stripLeadingHyphens(opt);
List matchingOpts = new ArrayList();
// for a perfect match return the single option only
if (longOpts.keySet().contains(opt))
{
return Collections.singletonList(opt);
}
for (String longOpt : longOpts.keySet())
{
if (longOpt.startsWith(opt))
{
matchingOpts.add(longOpt);
}
}
return matchingOpts;
}
/**
* Returns whether the named {@link Option} is a member of this {@link Options}.
*
* @param opt short or long name of the {@link Option}
* @return true if the named {@link Option} is a member of this {@link Options}
*/
public boolean hasOption(String opt)
{
opt = Util.stripLeadingHyphens(opt);
return shortOpts.containsKey(opt) || longOpts.containsKey(opt);
}
/**
* Returns whether the named {@link Option} is a member of this {@link Options}.
*
* @param opt long name of the {@link Option}
* @return true if the named {@link Option} is a member of this {@link Options}
* @since 1.3
*/
public boolean hasLongOption(String opt)
{
opt = Util.stripLeadingHyphens(opt);
return longOpts.containsKey(opt);
}
/**
* Returns whether the named {@link Option} is a member of this {@link Options}.
*
* @param opt short name of the {@link Option}
* @return true if the named {@link Option} is a member of this {@link Options}
* @since 1.3
*/
public boolean hasShortOption(String opt)
{
opt = Util.stripLeadingHyphens(opt);
return shortOpts.containsKey(opt);
}
/**
* Returns the OptionGroup the opt belongs to.
* @param opt the option whose OptionGroup is being queried.
*
* @return the OptionGroup if opt is part
* of an OptionGroup, otherwise return null
*/
public OptionGroup getOptionGroup(Option opt)
{
return optionGroups.get(opt.getKey());
}
/**
* Dump state, suitable for debugging.
*
* @return Stringified form of this object
*/
@Override
public String toString()
{
StringBuilder buf = new StringBuilder();
buf.append("[ Options: [ short ");
buf.append(shortOpts.toString());
buf.append(" ] [ long ");
buf.append(longOpts);
buf.append(" ]");
return buf.toString();
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/OptionValidator.java 0100644 0000765 0000024 00000006112 12537250704 030032 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
/**
* Validates an Option string.
*
* @version $Id: OptionValidator.java 1544819 2013-11-23 15:34:31Z tn $
* @since 1.1
*/
final class OptionValidator
{
/**
* Validates whether opt is a permissible Option
* shortOpt. The rules that specify if the opt
* is valid are:
*
*
* a single character opt that is either
* ' '(special case), '?', '@' or a letter
* a multi character opt that only contains
* letters.
*
*
* In case {@code opt} is {@code null} no further validation is performed.
*
* @param opt The option string to validate, may be null
* @throws IllegalArgumentException if the Option is not valid.
*/
static void validateOption(String opt) throws IllegalArgumentException
{
// if opt is NULL do not check further
if (opt == null)
{
return;
}
// handle the single character opt
if (opt.length() == 1)
{
char ch = opt.charAt(0);
if (!isValidOpt(ch))
{
throw new IllegalArgumentException("Illegal option name '" + ch + "'");
}
}
// handle the multi character opt
else
{
for (char ch : opt.toCharArray())
{
if (!isValidChar(ch))
{
throw new IllegalArgumentException("The option '" + opt + "' contains an illegal "
+ "character : '" + ch + "'");
}
}
}
}
/**
* Returns whether the specified character is a valid Option.
*
* @param c the option to validate
* @return true if c is a letter, '?' or '@', otherwise false.
*/
private static boolean isValidOpt(char c)
{
return isValidChar(c) || c == '?' || c == '@';
}
/**
* Returns whether the specified character is a valid character.
*
* @param c the character to validate
* @return true if c is a letter.
*/
private static boolean isValidChar(char c)
{
return Character.isJavaIdentifierPart(c);
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/overview.html 0100644 0000765 0000024 00000003255 12537250704 026612 0 ustar 00bene staff 0000000 0000000
Commons CLI -- version 1.3
The commons-cli package aides in parsing command-line arguments.
Allow command-line arguments to be parsed against a descriptor of
valid options (long and short), potentially with arguments.
command-line arguments may be of the typical String[]
form, but also may be a java.util.List. Indexes allow
for parsing only a portion of the command-line. Also, functionality
for parsing the command-line in phases is built in, allowing for
'cvs-style' command-lines, where some global options are specified
before a 'command' argument, and command-specific options are
specified after the command argument:
myApp -p <port> command -p <printer>
The homepage for the project is
Apache Commons/
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/package-info.java 0100644 0000765 0000024 00000001650 12537250704 027242 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Commons CLI 1.3
*
* @version $Id: package-info.java 1443102 2013-02-06 18:12:16Z tn $
*/
package org.apache.commons.cli;
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/ParseException.java 0100644 0000765 0000024 00000002574 12537250704 027655 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
/**
* Base for Exceptions thrown during parsing of a command-line.
*
* @version $Id: ParseException.java 1443102 2013-02-06 18:12:16Z tn $
*/
public class ParseException extends Exception
{
/**
* This exception {@code serialVersionUID}.
*/
private static final long serialVersionUID = 9112808380089253192L;
/**
* Construct a new ParseException
* with the specified detail message.
*
* @param message the detail message
*/
public ParseException(String message)
{
super(message);
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/Parser.java 0100644 0000765 0000024 00000033311 12537250704 026151 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.List;
import java.util.ListIterator;
import java.util.Properties;
/**
* Parser creates {@link CommandLine}s.
*
* @version $Id: Parser.java 1677406 2015-05-03 14:27:31Z britter $
* @deprecated since 1.3, the two-pass parsing with the flatten method is not enough flexible to handle complex cases
*/
@Deprecated
public abstract class Parser implements CommandLineParser
{
/** commandline instance */
protected CommandLine cmd;
/** current Options */
private Options options;
/** list of required options strings */
private List requiredOptions;
protected void setOptions(Options options)
{
this.options = options;
this.requiredOptions = new ArrayList(options.getRequiredOptions());
}
protected Options getOptions()
{
return options;
}
protected List getRequiredOptions()
{
return requiredOptions;
}
/**
* Subclasses must implement this method to reduce
* the arguments that have been passed to the parse method.
*
* @param opts The Options to parse the arguments by.
* @param arguments The arguments that have to be flattened.
* @param stopAtNonOption specifies whether to stop
* flattening when a non option has been encountered
* @return a String array of the flattened arguments
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*/
protected abstract String[] flatten(Options opts, String[] arguments, boolean stopAtNonOption)
throws ParseException;
/**
* Parses the specified arguments based
* on the specified {@link Options}.
*
* @param options the Options
* @param arguments the arguments
* @return the CommandLine
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*/
public CommandLine parse(Options options, String[] arguments) throws ParseException
{
return parse(options, arguments, null, false);
}
/**
* Parse the arguments according to the specified options and properties.
*
* @param options the specified Options
* @param arguments the command line arguments
* @param properties command line option name-value pairs
* @return the list of atomic option and value tokens
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*
* @since 1.1
*/
public CommandLine parse(Options options, String[] arguments, Properties properties) throws ParseException
{
return parse(options, arguments, properties, false);
}
/**
* Parses the specified arguments
* based on the specified {@link Options}.
*
* @param options the Options
* @param arguments the arguments
* @param stopAtNonOption if true an unrecognized argument stops
* the parsing and the remaining arguments are added to the
* {@link CommandLine}s args list. If false an unrecognized
* argument triggers a ParseException.
* @return the CommandLine
* @throws ParseException if an error occurs when parsing the arguments.
*/
public CommandLine parse(Options options, String[] arguments, boolean stopAtNonOption) throws ParseException
{
return parse(options, arguments, null, stopAtNonOption);
}
/**
* Parse the arguments according to the specified options and
* properties.
*
* @param options the specified Options
* @param arguments the command line arguments
* @param properties command line option name-value pairs
* @param stopAtNonOption if true an unrecognized argument stops
* the parsing and the remaining arguments are added to the
* {@link CommandLine}s args list. If false an unrecognized
* argument triggers a ParseException.
*
* @return the list of atomic option and value tokens
*
* @throws ParseException if there are any problems encountered
* while parsing the command line tokens.
*
* @since 1.1
*/
public CommandLine parse(Options options, String[] arguments, Properties properties, boolean stopAtNonOption)
throws ParseException
{
// clear out the data in options in case it's been used before (CLI-71)
for (Option opt : options.helpOptions())
{
opt.clearValues();
}
// clear the data from the groups
for (OptionGroup group : options.getOptionGroups())
{
group.setSelected(null);
}
// initialise members
setOptions(options);
cmd = new CommandLine();
boolean eatTheRest = false;
if (arguments == null)
{
arguments = new String[0];
}
List tokenList = Arrays.asList(flatten(getOptions(), arguments, stopAtNonOption));
ListIterator iterator = tokenList.listIterator();
// process each flattened token
while (iterator.hasNext())
{
String t = iterator.next();
// the value is the double-dash
if ("--".equals(t))
{
eatTheRest = true;
}
// the value is a single dash
else if ("-".equals(t))
{
if (stopAtNonOption)
{
eatTheRest = true;
}
else
{
cmd.addArg(t);
}
}
// the value is an option
else if (t.startsWith("-"))
{
if (stopAtNonOption && !getOptions().hasOption(t))
{
eatTheRest = true;
cmd.addArg(t);
}
else
{
processOption(t, iterator);
}
}
// the value is an argument
else
{
cmd.addArg(t);
if (stopAtNonOption)
{
eatTheRest = true;
}
}
// eat the remaining tokens
if (eatTheRest)
{
while (iterator.hasNext())
{
String str = iterator.next();
// ensure only one double-dash is added
if (!"--".equals(str))
{
cmd.addArg(str);
}
}
}
}
processProperties(properties);
checkRequiredOptions();
return cmd;
}
/**
* Sets the values of Options using the values in properties.
*
* @param properties The value properties to be processed.
* @throws ParseException if there are any problems encountered
* while processing the properties.
*/
protected void processProperties(Properties properties) throws ParseException
{
if (properties == null)
{
return;
}
for (Enumeration e = properties.propertyNames(); e.hasMoreElements();)
{
String option = e.nextElement().toString();
Option opt = options.getOption(option);
if (opt == null)
{
throw new UnrecognizedOptionException("Default option wasn't defined", option);
}
// if the option is part of a group, check if another option of the group has been selected
OptionGroup group = options.getOptionGroup(opt);
boolean selected = group != null && group.getSelected() != null;
if (!cmd.hasOption(option) && !selected)
{
// get the value from the properties instance
String value = properties.getProperty(option);
if (opt.hasArg())
{
if (opt.getValues() == null || opt.getValues().length == 0)
{
try
{
opt.addValueForProcessing(value);
}
catch (RuntimeException exp) //NOPMD
{
// if we cannot add the value don't worry about it
}
}
}
else if (!("yes".equalsIgnoreCase(value)
|| "true".equalsIgnoreCase(value)
|| "1".equalsIgnoreCase(value)))
{
// if the value is not yes, true or 1 then don't add the
// option to the CommandLine
continue;
}
cmd.addOption(opt);
updateRequiredOptions(opt);
}
}
}
/**
* Throws a {@link MissingOptionException} if all of the required options
* are not present.
*
* @throws MissingOptionException if any of the required Options are not present.
*/
protected void checkRequiredOptions() throws MissingOptionException
{
// if there are required options that have not been processed
if (!getRequiredOptions().isEmpty())
{
throw new MissingOptionException(getRequiredOptions());
}
}
/**
* Process the argument values for the specified Option
* opt using the values retrieved from the
* specified iterator iter.
*
* @param opt The current Option
* @param iter The iterator over the flattened command line Options.
*
* @throws ParseException if an argument value is required
* and it is has not been found.
*/
public void processArgs(Option opt, ListIterator iter) throws ParseException
{
// loop until an option is found
while (iter.hasNext())
{
String str = iter.next();
// found an Option, not an argument
if (getOptions().hasOption(str) && str.startsWith("-"))
{
iter.previous();
break;
}
// found a value
try
{
opt.addValueForProcessing(Util.stripLeadingAndTrailingQuotes(str));
}
catch (RuntimeException exp)
{
iter.previous();
break;
}
}
if (opt.getValues() == null && !opt.hasOptionalArg())
{
throw new MissingArgumentException(opt);
}
}
/**
* Process the Option specified by arg using the values
* retrieved from the specified iterator iter.
*
* @param arg The String value representing an Option
* @param iter The iterator over the flattened command line arguments.
*
* @throws ParseException if arg does not represent an Option
*/
protected void processOption(String arg, ListIterator iter) throws ParseException
{
boolean hasOption = getOptions().hasOption(arg);
// if there is no option throw an UnrecognisedOptionException
if (!hasOption)
{
throw new UnrecognizedOptionException("Unrecognized option: " + arg, arg);
}
// get the option represented by arg
Option opt = (Option) getOptions().getOption(arg).clone();
// update the required options and groups
updateRequiredOptions(opt);
// if the option takes an argument value
if (opt.hasArg())
{
processArgs(opt, iter);
}
// set the option on the command line
cmd.addOption(opt);
}
/**
* Removes the option or its group from the list of expected elements.
*
* @param opt
*/
private void updateRequiredOptions(Option opt) throws ParseException
{
// if the option is a required option remove the option from
// the requiredOptions list
if (opt.isRequired())
{
getRequiredOptions().remove(opt.getKey());
}
// if the option is in an OptionGroup make that option the selected
// option of the group
if (getOptions().getOptionGroup(opt) != null)
{
OptionGroup group = getOptions().getOptionGroup(opt);
if (group.isRequired())
{
getRequiredOptions().remove(group);
}
group.setSelected(opt);
}
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/PatternOptionBuilder.java 0100644 0000765 0000024 00000014532 12537250704 031036 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.io.File;
import java.io.FileInputStream;
import java.net.URL;
import java.util.Date;
/**
* Allows Options to be created from a single String.
* The pattern contains various single character flags and via
* an optional punctuation character, their expected type.
*
*
*
* Overview of PatternOptionBuilder patterns
* a -a flag b@ -b [classname] c> -c [filename] d+ -d [classname] (creates object via empty constructor) e% -e [number] (creates Double/Long instance depending on existing of a '.') f/ -f [url] g: -g [string]
*
*
* For example, the following allows command line flags of '-v -p string-value -f /dir/file'.
* The exclamation mark precede a mandatory option.
*
*
*
* Options options = PatternOptionBuilder.parsePattern("vp:!f/");
*
*
*
* TODO: These need to break out to OptionType and also to be pluggable.
*
*
* @version $Id: PatternOptionBuilder.java 1677406 2015-05-03 14:27:31Z britter $
*/
public class PatternOptionBuilder
{
/** String class */
public static final Class STRING_VALUE = String.class;
/** Object class */
public static final Class OBJECT_VALUE = Object.class;
/** Number class */
public static final Class NUMBER_VALUE = Number.class;
/** Date class */
public static final Class DATE_VALUE = Date.class;
/** Class class */
public static final Class CLASS_VALUE = Class.class;
/// can we do this one??
// is meant to check that the file exists, else it errors.
// ie) it's for reading not writing.
/** FileInputStream class */
public static final Class EXISTING_FILE_VALUE = FileInputStream.class;
/** File class */
public static final Class FILE_VALUE = File.class;
/** File array class */
public static final Class FILES_VALUE = File[].class;
/** URL class */
public static final Class URL_VALUE = URL.class;
/**
* Retrieve the class that ch represents.
*
* @param ch the specified character
* @return The class that ch represents
*/
public static Object getValueClass(char ch)
{
switch (ch)
{
case '@':
return PatternOptionBuilder.OBJECT_VALUE;
case ':':
return PatternOptionBuilder.STRING_VALUE;
case '%':
return PatternOptionBuilder.NUMBER_VALUE;
case '+':
return PatternOptionBuilder.CLASS_VALUE;
case '#':
return PatternOptionBuilder.DATE_VALUE;
case '<':
return PatternOptionBuilder.EXISTING_FILE_VALUE;
case '>':
return PatternOptionBuilder.FILE_VALUE;
case '*':
return PatternOptionBuilder.FILES_VALUE;
case '/':
return PatternOptionBuilder.URL_VALUE;
}
return null;
}
/**
* Returns whether ch is a value code, i.e.
* whether it represents a class in a pattern.
*
* @param ch the specified character
* @return true if ch is a value code, otherwise false.
*/
public static boolean isValueCode(char ch)
{
return ch == '@'
|| ch == ':'
|| ch == '%'
|| ch == '+'
|| ch == '#'
|| ch == '<'
|| ch == '>'
|| ch == '*'
|| ch == '/'
|| ch == '!';
}
/**
* Returns the {@link Options} instance represented by pattern.
*
* @param pattern the pattern string
* @return The {@link Options} instance
*/
public static Options parsePattern(String pattern)
{
char opt = ' ';
boolean required = false;
Class type = null;
Options options = new Options();
for (int i = 0; i < pattern.length(); i++)
{
char ch = pattern.charAt(i);
// a value code comes after an option and specifies
// details about it
if (!isValueCode(ch))
{
if (opt != ' ')
{
final Option option = Option.builder(String.valueOf(opt))
.hasArg(type != null)
.required(required)
.type(type)
.build();
// we have a previous one to deal with
options.addOption(option);
required = false;
type = null;
opt = ' ';
}
opt = ch;
}
else if (ch == '!')
{
required = true;
}
else
{
type = (Class) getValueClass(ch);
}
}
if (opt != ' ')
{
final Option option = Option.builder(String.valueOf(opt))
.hasArg(type != null)
.required(required)
.type(type)
.build();
// we have a final one to deal with
options.addOption(option);
}
return options;
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/PosixParser.java 0100644 0000765 0000024 00000024526 12537250704 027204 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* The class PosixParser provides an implementation of the
* {@link Parser#flatten(Options,String[],boolean) flatten} method.
*
* @version $Id: PosixParser.java 1677451 2015-05-03 17:09:29Z ggregory $
* @deprecated since 1.3, use the {@link DefaultParser} instead
*/
@Deprecated
public class PosixParser extends Parser
{
/** holder for flattened tokens */
private final List tokens = new ArrayList();
/** specifies if bursting should continue */
private boolean eatTheRest;
/** holder for the current option */
private Option currentOption;
/** the command line Options */
private Options options;
/**
* Resets the members to their original state i.e. remove
* all of tokens entries and set eatTheRest
* to false.
*/
private void init()
{
eatTheRest = false;
tokens.clear();
}
/**
* An implementation of {@link Parser}'s abstract
* {@link Parser#flatten(Options,String[],boolean) flatten} method.
*
* The following are the rules used by this flatten method.
*
* if stopAtNonOption is true then do not
* burst anymore of arguments entries, just add each
* successive entry without further processing. Otherwise, ignore
* stopAtNonOption.
* if the current arguments entry is "-- "
* just add the entry to the list of processed tokens
* if the current arguments entry is "- "
* just add the entry to the list of processed tokens
* if the current arguments entry is two characters
* in length and the first character is "- " then check if this
* is a valid {@link Option} id. If it is a valid id, then add the
* entry to the list of processed tokens and set the current {@link Option}
* member. If it is not a valid id and stopAtNonOption
* is true, then the remaining entries are copied to the list of
* processed tokens. Otherwise, the current entry is ignored.
* if the current arguments entry is more than two
* characters in length and the first character is "- " then
* we need to burst the entry to determine its constituents. For more
* information on the bursting algorithm see
* {@link PosixParser#burstToken(String, boolean) burstToken}.
* if the current arguments entry is not handled
* by any of the previous rules, then the entry is added to the list
* of processed tokens.
*
*
* @param options The command line {@link Options}
* @param arguments The command line arguments to be parsed
* @param stopAtNonOption Specifies whether to stop flattening
* when an non option is found.
* @return The flattened arguments String array.
*/
@Override
protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption) throws ParseException
{
init();
this.options = options;
// an iterator for the command line tokens
Iterator iter = Arrays.asList(arguments).iterator();
// process each command line token
while (iter.hasNext())
{
// get the next command line token
String token = iter.next();
// single or double hyphen
if ("-".equals(token) || "--".equals(token))
{
tokens.add(token);
}
// handle long option --foo or --foo=bar
else if (token.startsWith("--"))
{
int pos = token.indexOf('=');
String opt = pos == -1 ? token : token.substring(0, pos); // --foo
List matchingOpts = options.getMatchingOptions(opt);
if (matchingOpts.isEmpty())
{
processNonOptionToken(token, stopAtNonOption);
}
else if (matchingOpts.size() > 1)
{
throw new AmbiguousOptionException(opt, matchingOpts);
}
else
{
currentOption = options.getOption(matchingOpts.get(0));
tokens.add("--" + currentOption.getLongOpt());
if (pos != -1)
{
tokens.add(token.substring(pos + 1));
}
}
}
else if (token.startsWith("-"))
{
if (token.length() == 2 || options.hasOption(token))
{
processOptionToken(token, stopAtNonOption);
}
else if (!options.getMatchingOptions(token).isEmpty())
{
List matchingOpts = options.getMatchingOptions(token);
if (matchingOpts.size() > 1)
{
throw new AmbiguousOptionException(token, matchingOpts);
}
Option opt = options.getOption(matchingOpts.get(0));
processOptionToken("-" + opt.getLongOpt(), stopAtNonOption);
}
// requires bursting
else
{
burstToken(token, stopAtNonOption);
}
}
else
{
processNonOptionToken(token, stopAtNonOption);
}
gobble(iter);
}
return tokens.toArray(new String[tokens.size()]);
}
/**
* Adds the remaining tokens to the processed tokens list.
*
* @param iter An iterator over the remaining tokens
*/
private void gobble(Iterator iter)
{
if (eatTheRest)
{
while (iter.hasNext())
{
tokens.add(iter.next());
}
}
}
/**
* Add the special token "-- " and the current value
* to the processed tokens list. Then add all the remaining
* argument values to the processed tokens list.
*
* @param value The current token
*/
private void processNonOptionToken(String value, boolean stopAtNonOption)
{
if (stopAtNonOption && (currentOption == null || !currentOption.hasArg()))
{
eatTheRest = true;
tokens.add("--");
}
tokens.add(value);
}
/**
* If an {@link Option} exists for token then
* add the token to the processed list.
*
* If an {@link Option} does not exist and stopAtNonOption
* is set then add the remaining tokens to the processed tokens list
* directly.
*
* @param token The current option token
* @param stopAtNonOption Specifies whether flattening should halt
* at the first non option.
*/
private void processOptionToken(String token, boolean stopAtNonOption)
{
if (stopAtNonOption && !options.hasOption(token))
{
eatTheRest = true;
}
if (options.hasOption(token))
{
currentOption = options.getOption(token);
}
tokens.add(token);
}
/**
* Breaks token into its constituent parts
* using the following algorithm.
*
*
* ignore the first character ("- ")
* foreach remaining character check if an {@link Option}
* exists with that id.
* if an {@link Option} does exist then add that character
* prepended with "- " to the list of processed tokens.
* if the {@link Option} can have an argument value and there
* are remaining characters in the token then add the remaining
* characters as a token to the list of processed tokens.
* if an {@link Option} does NOT exist AND
* stopAtNonOption IS set then add the special token
* "-- " followed by the remaining characters and also
* the remaining tokens directly to the processed tokens list.
* if an {@link Option} does NOT exist AND
* stopAtNonOption IS NOT set then add that
* character prepended with "- ".
*
*
* @param token The current token to be burst
* @param stopAtNonOption Specifies whether to stop processing
* at the first non-Option encountered.
*/
protected void burstToken(String token, boolean stopAtNonOption)
{
for (int i = 1; i < token.length(); i++)
{
String ch = String.valueOf(token.charAt(i));
if (options.hasOption(ch))
{
tokens.add("-" + ch);
currentOption = options.getOption(ch);
if (currentOption.hasArg() && token.length() != i + 1)
{
tokens.add(token.substring(i + 1));
break;
}
}
else if (stopAtNonOption)
{
processNonOptionToken(token.substring(i), true);
break;
}
else
{
tokens.add(token);
break;
}
}
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/TypeHandler.java 0100644 0000765 0000024 00000016257 12537250704 027146 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Date;
/**
* This is a temporary implementation. TypeHandler will handle the
* pluggableness of OptionTypes and it will direct all of these types
* of conversion functionalities to ConvertUtils component in Commons
* already. BeanUtils I think.
*
* @version $Id: TypeHandler.java 1677452 2015-05-03 17:10:00Z ggregory $
*/
public class TypeHandler
{
/**
* Returns the Object of type obj
* with the value of str.
*
* @param str the command line value
* @param obj the type of argument
* @return The instance of obj initialised with
* the value of str.
* @throws ParseException if the value creation for the given object type failed
*/
public static Object createValue(String str, Object obj) throws ParseException
{
return createValue(str, (Class) obj);
}
/**
* Returns the Object of type clazz
* with the value of str.
*
* @param str the command line value
* @param clazz the type of argument
* @return The instance of clazz initialised with
* the value of str.
* @throws ParseException if the value creation for the given class failed
*/
public static Object createValue(String str, Class clazz) throws ParseException
{
if (PatternOptionBuilder.STRING_VALUE == clazz)
{
return str;
}
else if (PatternOptionBuilder.OBJECT_VALUE == clazz)
{
return createObject(str);
}
else if (PatternOptionBuilder.NUMBER_VALUE == clazz)
{
return createNumber(str);
}
else if (PatternOptionBuilder.DATE_VALUE == clazz)
{
return createDate(str);
}
else if (PatternOptionBuilder.CLASS_VALUE == clazz)
{
return createClass(str);
}
else if (PatternOptionBuilder.FILE_VALUE == clazz)
{
return createFile(str);
}
else if (PatternOptionBuilder.EXISTING_FILE_VALUE == clazz)
{
return createFile(str);
}
else if (PatternOptionBuilder.FILES_VALUE == clazz)
{
return createFiles(str);
}
else if (PatternOptionBuilder.URL_VALUE == clazz)
{
return createURL(str);
}
else
{
return null;
}
}
/**
* Create an Object from the classname and empty constructor.
*
* @param classname the argument value
* @return the initialised object
* @throws ParseException if the class could not be found or the object could not be created
*/
public static Object createObject(String classname) throws ParseException
{
Class cl;
try
{
cl = Class.forName(classname);
}
catch (ClassNotFoundException cnfe)
{
throw new ParseException("Unable to find the class: " + classname);
}
try
{
return cl.newInstance();
}
catch (Exception e)
{
throw new ParseException(e.getClass().getName() + "; Unable to create an instance of: " + classname);
}
}
/**
* Create a number from a String. If a . is present, it creates a
* Double, otherwise a Long.
*
* @param str the value
* @return the number represented by str
* @throws ParseException if str is not a number
*/
public static Number createNumber(String str) throws ParseException
{
try
{
if (str.indexOf('.') != -1)
{
return Double.valueOf(str);
}
return Long.valueOf(str);
}
catch (NumberFormatException e)
{
throw new ParseException(e.getMessage());
}
}
/**
* Returns the class whose name is classname.
*
* @param classname the class name
* @return The class if it is found
* @throws ParseException if the class could not be found
*/
public static Class createClass(String classname) throws ParseException
{
try
{
return Class.forName(classname);
}
catch (ClassNotFoundException e)
{
throw new ParseException("Unable to find the class: " + classname);
}
}
/**
* Returns the date represented by str.
*
* This method is not yet implemented and always throws an
* {@link UnsupportedOperationException}.
*
* @param str the date string
* @return The date if str is a valid date string,
* otherwise return null.
* @throws UnsupportedOperationException always
*/
public static Date createDate(String str)
{
throw new UnsupportedOperationException("Not yet implemented");
}
/**
* Returns the URL represented by str.
*
* @param str the URL string
* @return The URL in str is well-formed
* @throws ParseException if the URL in str is not well-formed
*/
public static URL createURL(String str) throws ParseException
{
try
{
return new URL(str);
}
catch (MalformedURLException e)
{
throw new ParseException("Unable to parse the URL: " + str);
}
}
/**
* Returns the File represented by str.
*
* @param str the File location
* @return The file represented by str.
*/
public static File createFile(String str)
{
return new File(str);
}
/**
* Returns the File[] represented by str.
*
* This method is not yet implemented and always throws an
* {@link UnsupportedOperationException}.
*
* @param str the paths to the files
* @return The File[] represented by str.
* @throws UnsupportedOperationException always
*/
public static File[] createFiles(String str)
{
// to implement/port:
// return FileW.findFiles(str);
throw new UnsupportedOperationException("Not yet implemented");
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/UnrecognizedOptionException.java 0100644 0000765 0000024 00000004075 12537250704 032426 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
/**
* Exception thrown during parsing signalling an unrecognized
* option was seen.
*
* @version $Id: UnrecognizedOptionException.java 1443102 2013-02-06 18:12:16Z tn $
*/
public class UnrecognizedOptionException extends ParseException
{
/**
* This exception {@code serialVersionUID}.
*/
private static final long serialVersionUID = -252504690284625623L;
/** The unrecognized option */
private String option;
/**
* Construct a new UnrecognizedArgumentException
* with the specified detail message.
*
* @param message the detail message
*/
public UnrecognizedOptionException(String message)
{
super(message);
}
/**
* Construct a new UnrecognizedArgumentException
* with the specified option and detail message.
*
* @param message the detail message
* @param option the unrecognized option
* @since 1.2
*/
public UnrecognizedOptionException(String message, String option)
{
this(message);
this.option = option;
}
/**
* Returns the unrecognized option.
*
* @return the related option
* @since 1.2
*/
public String getOption()
{
return option;
}
}
commons-cli-1.3.1-src/src/main/java/org/apache/commons/cli/Util.java 0100644 0000765 0000024 00000004310 12537250704 025627 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
/**
* Contains useful helper methods for classes within this package.
*
* @version $Id: Util.java 1443102 2013-02-06 18:12:16Z tn $
*/
final class Util
{
/**
* Remove the hyphens from the beginning of str and
* return the new String.
*
* @param str The string from which the hyphens should be removed.
*
* @return the new String.
*/
static String stripLeadingHyphens(String str)
{
if (str == null)
{
return null;
}
if (str.startsWith("--"))
{
return str.substring(2, str.length());
}
else if (str.startsWith("-"))
{
return str.substring(1, str.length());
}
return str;
}
/**
* Remove the leading and trailing quotes from str.
* E.g. if str is '"one two"', then 'one two' is returned.
*
* @param str The string from which the leading and trailing quotes
* should be removed.
*
* @return The string without the leading and trailing quotes.
*/
static String stripLeadingAndTrailingQuotes(String str)
{
int length = str.length();
if (length > 1 && str.startsWith("\"") && str.endsWith("\"") && str.substring(1, length - 1).indexOf('"') == -1)
{
str = str.substring(1, length - 1);
}
return str;
}
}
commons-cli-1.3.1-src/src/media/logo.xcf 0100644 0000765 0000024 00000051273 12537250704 020503 0 ustar 00bene staff 0000000 0000000 gimp xcf file , d B B K
gimp-comment Created with The GIMP gimp-image-grid (style solid)
(fgcolor (color-rgba 0.000000 0.000000 0.000000 1.000000))
(bgcolor (color-rgba 1.000000 1.000000 1.000000 1.000000))
(xspacing 10.000000)
(yspacing 10.000000)
(spacing-unit inches)
(xoffset 0.000000)
(yoffset 0.000000)
(offset-unit inches)
Ê n ò / M Oz Q X &
Text Layer#2 ˙
3 s X & b X & í Uŝ ŝU U ü qŞ˙˙ûâŞU üq˙U ŭŞĈ˙
˙Ş ŭ8Ş˙˙Şŝâ˙˙ùâŞĈ˙˙U ŝq˙˙ŭâ8 ŭ Ş˙˙üâ8 ŭUĈ˙˙ŝU ŝq˙˙ŝ ŝU˙˙ŝ
ŭUâ˙˙ŝU ŝ ˙˙ŝĈ ŝŞ˙˙ŭâ8 ŭ Ĉ˙˙ŝU ˙ŝŞ ŝŞ˙˙ŭâ ŝŞ˙˙ŝU ˙ŝŞ ŝU˙˙ŝU ú â˙˙U ˙ŝŞ ŝ8˙˙ŝ û8˙˙q ˙ŝŞ ŝĈ˙˙ŝ üĈ˙Ş ˙ŝŞ ŝq˙˙ŝ üq˙Ş ˙ŝŞ ŝĈ˙˙ŝ ŭ˙Ş ˙ŝŞ ŝ8˙˙ŝĈ q ˙ŝŞ ŝ˙˙ŝŞ ˙ŝŞ ŝĈ˙˙ŝU ˙ŝŞ ˙ŝU ˙ŝŞ ŝ ˙˙" ˙ŝŞ ŝU˙˙" ˙ŝŞ ŝU˙˙" ˙ŝŞ ŝU˙˙" ˙ŝŞ ŝU˙˙" ˙ŝŞ ŝU˙˙ŝ ˙ŝŞ ˙ŝU ˙ŝŞ ˙ŝU ˙ŝŞ ŝŞ˙˙ŝŞ ˙ŝŞ ŝq˙˙ŝâ ˙ŝŞ ŝ ˙˙ŝ8 ˙ŝŞ ŝĈ˙˙ŝ ˙ŝŞ ŝ8˙˙ŝ ˙ŝŞ ŝĈ˙˙ŝ ˙ŝŞ ŝ ˙˙ŝU üUâ ˙ŝŞ ŝU˙˙ŭâ üq˙â ˙ŝŞ ŝU˙˙ŭâU ú Ĉ˙â ˙ŝŞ ŝU˙˙ŭ
ù ˙˙Ş ˙ŝŞ ŭ Ĉ˙˙ŭŞU ŭU˙˙ŝq ŝU˙˙ŝâ ŭ8Ĉ ŭqâ˙˙ŝ⪪ŝâ˙˙ŭ ŭ â˙˙ŭĈUUŭŞ˙˙
ŭ8Ş˙
˙üĈq üUqŞ˙˙
ü8UŞŞU Ş ŝ UU ü8Şâ˙
˙Ş
ŝq˙˙ŭâ8
ŝq˙˙ŝ ŝ ˙˙ŝĈ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ ˙ŝŞ Ĉ ˙ŝŞ ü ˙q ˙ŝŞ üĈ˙8 ˙ŝŞ üU˙˙ ˙ŝŞ û â˙Ş ˙ŝŞ úUâ˙˙U ˙ŝĈ ˙ŝ ŝU˙˙ ˙ŝĈ ŝĈ˙˙ŝŞ ˙ŝ ú UUŞâ˙˙ûâŞUUŞŞŝ8 ŝ8ŞŞ , v D Drop-Shadow#2 Ì
§ , v D 0 ĉ v D L ĉ Ĉ Ö 5
ö û
ŭ
ó
ù
ŭ
ñ
ô ï
ŝù ü í
ŭ ù "$&((ü&$!
í
!"##$%&%í$#!! !"%'*.02321.* î "%'())*ü+,-..ì-,*)('(),/37:<==:72 è $'*-./0//..--.û/12455í420/./037<@DGHGD@: î #(-03566û543211ä2468:;<=<;976557;?DINQRRNIB è &,159;<=<;975322ä468;=@ABBA?=;:;=@EKQVZ[ZWQI Ö !(.4:>ACCB@>;8632112369HQX]__\VOG?6/(" #',158;<<ñ=?CIQZckqsrmdY â $/:EOX_cdb]VND;2*# ä !%*.1456779<@GPYckqsrmdY â )4@KV_ehhd^ULA7-% ä #'*-.01248>ENXbkqsrmdY â #.9FQ\djlje^TI>3)
ä
#%()+-04:CLWajpsrmdX &2>KWainolf]RF:/%
!#%'+07@JU`iprqlcX
*6CP\fmqqmf\PC7+!
"',4>HT_horqlcX !-9FT`jqtsnf[NA4(
#)1;GS^hnrqlcW á #/LZfpvxuoeYK=0$
ċ
$-8DQ\gnqpkcW á
&2@N\hqwyvoeXJ1%
ì )5BO\fnqpkcW à %1>LZfpwywqh\N@3' ë )5BO[fmqpkcW à #/KXckqsqlcYMB6,#
é
#-8DQ]gorrmeY ß "-9FR]fmpole\QF;1(
ç
%.9ER^hosrnf[ à
)4@LW`hlmke^UJ@6.& è !'0;GS_ipssog\ ß
$.9EPZbgiie_WNE<4,&! î #)2HR[adec_YQIA92,'# î !%+3=HT_iossoh^ Ŝ #,6@JSY^``^YSMF?82-)&#" ï #&,4=HS^hnrroh_ Ŝ &/8AJQVZ[ZXSNHC=73/+)'&%$$##ŝ"!!ï"$(-4=HS]fmpqnh_ Ĝ
(09AHNRUVTRNJE@<741.,*)(''&%$#""$',3:742/.,+*)'&%#""#&+2:CMV^dhhfb[ Ç !(.5;@DGIIHFDA>;8631/.,*)'%$"! "$)/6?HPX]aa`\W Ú &,16;>@ABA@><:7531/-+)'%#! "&+2:BJPUYZXUQ ï #(-1579::Ŭ986420.,*(&$" "'-4;AGLOPOMI É $(+.0223210/-,*(&$" !',28=ADEDB@ í #%')*++ß*)('%#" %*/379:986
î
!"##à"! "&),.//., à
!#$%%$# ñ
ġ
ġ
ô
ç
ŝ ġ
ĝ ÷
ĝú ü
Ĝ ŝ
ŝ
ŝ ù ĝù ö ÷
ô
ġ ô
ó ô
á
ó â ġ
Ŭ "%'((&$!
ô%
à !&+/1220.*%
ô,& ß "(.48;=<:72,& ô3,$
Ŝ
'.62'
à !+6BNYbilkg`VJ>2'
K?3'
+6CO[elonjbWK?3'
óL?2' ß *6CP\fmqpkcXL?2' óL?2' ß
*6CP]gnrqldYL?2' óL?2&
ß
)5CP\gnrqldYL?2&
ôL>1&
à
)5CP\gnrqmdYL>1&
ôK>1%
á (5BO\gnrqldXK>1%
ôK=0% á (4AO\fnqqlcXK=0% ôK=0$ á (4AO[fnqqlcXK=0$ ôJ=0$ á '4AN[fmqpkcWJ=0$ ôJ=0$ á '4AN[fmqpkcWJ=0$ ôJ=0$ á '4AN[emqpkcWJ=0$ ôJ=0$ â (4AO[fmqpkcWJ=0$ ôJ=0$ à (4AO[fmqpkcWJ=0$ ÑJ=0$
(4BO[fnqpkcWJ=0$ ġJ=0$ à )5BO\fnqpkcWJ=0$ ôJ=0$ ß *5BO\fnqplcWJ=0$ ġJ=0$ à
!+6CP\fnqpkcWJ=0$ ġJ=0$
Ŝ
",7DP]gnqpkcWJ=0$ öK>1%
Ŭ
%.9ER]gnrqlcXK=0$ öL>2& Ŭ
'0;FS^horqlcXK=0% ÑM@3(
$*3=HT_iorqldXK>1% ÑNB5*! #(.6?JU`ipsrldXK>1%
PC7-$ !#%(,29BLWajpsrmdYL?2&
RF:0' !$&')+-05;DMWajpsrmdYL?2& SH=3*$ #%(*,./0148>ENXbjprqldYL?3' UJ?6/)%#""$&),.1234457:@FOXainqokcXL?3'
îVLB:3.*(()*-/256788ċ9842012368:<==<;:9:;?DJQX_ced`YPF;0&
ñPIC=853223579;==à<:9879;@ELRX\]\YSKA7-$
ùLF@<8533ú4679:;;à9864457;@EKPTUTQLE<3*"
ùE@<85211û235677ß65310/0259>CGJKKHC=6.&
ù<9520.--û./0122à0/-+*))+.159=?A@>:5.(! ù41.,*)((Ù)*++,,+*('%$##$')-0356640,'"
ú*(&%#""#$ò"! !$')++*'$ ú" ñ ""! ûûúñ ŭû
ú
ò
ŝ
ŝ ó
÷
$ Ĝ Ĝ Ĝ Ĝ ; " × Text Layer ˙
× µ / / × Ñ $Ö (Ô -{ ŭ8qŞŞüU ŭ8UŞŞŭq8 ü q8 ŭqâ˙˙ŭŞ ŭqâ˙˙üâ
úUŞ˙˙U ġ8â˙˙8 Ş˙˙ŝU ôUâ˙˙8 qâ˙˙ŝU ü qŞ˙˙ŝU úU˙˙Ĉ ŝĈ˙˙ŝU ŝq˙˙ŝU ŝŞ˙˙ŝŞ üŞŞ˙˙üU Ĉ ûU˙˙â ŝq˙˙ŝâ ŝU˙˙ŝU ŝŞ˙˙ŝŞ ŝq˙˙ùŞ˙Ĉ 8˙˙ŝ ŝ ˙˙ŝU ŝ8˙˙ŝĈ ŝâ˙˙ŝU ˙ŝŞ ûâ˙˙ ŝĈ˙˙ŝ ŝĈ˙˙ŝU ŝ8˙˙ŝâ ˙ŝĈ ŝq˙˙ŝ8 ú â˙˙U ŝ8˙˙ ŝâ˙˙ŝq ˙ŝŞ ŝĈ˙˙ ŝ ŝŞ˙˙ŝĈ ŝ˙˙ŝĈ ˙ûŞ ˙˙ŝĈ ˙ŝŞ ŝ8˙˙ ˙ûŞ U˙˙ŝŞ ŝ ˙˙ŝŞ ˙ŝ8 ˙ûŞ ˙˙ŝŞ ŝU˙˙ŝŞ ŝâ˙˙ŝU ˙ûŞ Ş˙˙ŝŞ ŝU˙˙ŝŞ ŝŞ˙˙ŝU ˙ûŞ Ş˙˙ŝâ ŝU˙˙
ŝŞ˙˙ŝU ˙ûŞ Ş˙˙ ŝU˙˙
ŝŞ˙˙ŝ8 ˙ûŞ Ş˙˙ŝU ˙ŝU ŝŞ˙˙ ˙ûŞ U˙˙ŝĈ
ŝ8 ŝâ˙˙ŝ ŝŞ˙˙ŝĈ ˙ûŞ 8˙˙ŝ8 ŭUâ ŝ˙˙ŝĈ ˙ŝq ˙ŝŞ ŝâ˙˙ŭâ ü8˙8 ŝ8˙˙ŝ8 ŝ ˙˙ŝ ˙ŝŞ ŝq˙˙ŭŞ ü8âĈ ŝĈ˙˙ŝ ŝq˙˙ŝ ˙ŝŞ ŝâ˙˙ŭâ8 ûq˙˙ ŝ ˙˙ŝ ûâ˙˙â ˙ŝŞ ŝU˙˙ŭâUUúâ˙˙U ŝU˙˙ŝĈ úq˙˙â ˙ŝŞ ŝU˙ ˙ŝU ŝU˙˙ŝŞ úU˙˙â ŝ ˙˙ŝŞ ŝU˙ ˙ŭâU
ŭ8â˙˙ôâq UĈ˙˙Ĉ ŝq˙˙ŝ ŭ Ĉ˙˙ŭ
ŭqâ˙˙ŭĈ8 üUqĈ˙˙ŭ⪠ŭ UŞŞŭU ŭ8qŞŞŭU
Ş ù8qŞŞ8 ùUŞŞ8
ŭ8 ùUŞŞq ù UŞ 8Ĉ˙˙ŭĈ ŭqâ˙˙ŭĈ ú qĈ˙˙ ŭqâ˙˙ŝ ŭ ˙˙ŝ˙˙ŝĈ ŭ8â˙˙ŝâ ü8Ĉ˙˙ ŭ Ĉ˙˙ŝq ŝq˙˙úâUU˙˙ùq U˙˙ŞUUŭâ˙˙ŝq üĈŞĈ˙˙ö Uâ˙ĈqUUĈ˙˙ù Ş˙âUUŝ8 ŝ ˙˙úâU˙Ş ŭ â˙˙ŝâ ŝĈ˙˙ûŞ˙ ŝq˙˙ûŞ˙q
ŝ˙˙ŝŞ ŝq˙˙ŝ8 ŝU˙˙ŝU ŝâ˙˙ŝU ŝ8˙˙ŝĈ ŝ8˙˙ŝU ŝU˙˙ŝq ŝ˙˙ŝq
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU
˙ŝŞ ˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU ŝ ˙˙ŝâ ˙ŝĈ ŝq˙˙ŝU ŝq˙˙ŝ ŝq˙˙ŝU ŝq˙˙ŝ ŝĈ˙˙ŝĈ ŝĈ˙˙ŭâ ĝU 8qĈ˙˙÷ŞU8 8qĈ˙˙÷âU8 Uâ˙˙üĈU üUâ˙˙óâU UŞ8 qŞ Şûq qŞ Şŭq8Ş
Ş Şü8 Ş Şŭq ü UŞŞŭU ü88 ŭ qŞŞŝU ˙ŝ ŭ8Ĉ˙˙ŭŞ8 ġ8â˙˙U ˙˙ŭâU ˙ŝ ù Ĉ˙˙ĈU ŭUĈ˙˙ŝŞ üUŞâ˙˙ûU 8â˙˙ûU Ş˙˙ŝ ú8â˙˙Ş ŝU˙˙ŭâ Ş˙Uĝ˙âUUâ˙˙ŝâ ŝU˙˙ŝ ú â˙˙Ş ŝU˙˙ŭâ ŝŞ˙˙ûâ˙Ş ŝĈ˙˙ŝU ŝĈ˙˙ŝâ ŝâ˙˙ŝ ŝ˙˙ŝŞ ŝU˙˙ŝU ŝ8˙˙ŝŞ ŝ˙˙ ŝq˙˙ŝŞ
ŝâ˙˙ŝ8 ŝU˙˙ŝq ŝâ˙˙ŝâ ŝU˙˙ŝU ŝâ˙˙ŝU
ŝ˙˙ŝĈ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝU˙˙ŝ
ŝ8˙˙ŝ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝŞ˙˙
ŝâ˙˙ŝU ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝĈ˙˙
ŝŞ˙˙ŝ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ˙
ŝ˙˙ŝŞ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ˙
ŝU˙˙ŝŞ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ˙ŝU ŝU˙˙ŝŞ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ˙ŝU ŝU˙˙ŝ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝŞ˙˙ŝŞ ŝU˙˙ŝU ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝ˙˙ŝâ ŝU˙˙ŝ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝ8˙˙ŝ
ŝŞ˙˙ŝĈ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝâ˙˙ŝ
ŝĈ˙˙ŝq ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝq˙˙ŝâ ŝ ˙˙ŝâ ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŝĈ˙˙ŝq ŝ˙˙ŝ8 ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝU ŭ â˙˙ŝ ŝ ˙˙ŝU ŝU˙˙ŝU ŝŞ˙˙ ŝU˙˙ŝq ŭ â˙˙ŭâ ú â˙˙U ŝq˙˙ŝU ŝâ˙˙û Ĉ˙˙ŝĈ ŭ Ş˙˙ġ8 8˙˙âU ŝâ˙˙ŝĈ ŝU˙˙üqâ˙˙ûĈqU ŭ8Ĉ˙˙ŭâq ü8qâ˙˙÷âU UŞ˙˙
Şŝ8 ŭ UŞŞŭq8 ŝqŞ Ş ŝ8ŞŞV V V
ŭUŞŞúU ó˙˙⪪Ĉ˙˙ŞĈ˙ ûĈ˙â8 ŭ8Ĉ˙˙ ûŞ˙˙8 üâ˙˙ û8˙˙Ĉ ü8˙˙ û˙˙Ş ŭŞ˙ ûŞ˙˙â ŭU˙ ŝŞ˙˙ŝq ŝ˙ ŝq˙˙ŝq ŝ8 ŝ ˙˙ŭĈ8 ŝ˙˙ŭĈ
ŝŞ˙˙ŭ ŝ˙˙ŭâq ŭ8â˙˙ŭâ ŝq˙˙ŭâU ŭ ˙˙ŭâ
ŭ Ş˙˙ŝ ŭŞq ŝU˙˙ŝâ Ş ŝ˙˙ ŭŞ˙ ŝ ˙˙ üŞ˙q ˙ŝĈ ûŞ˙â ŝ ˙˙ŝq ûŞ˙˙Ş û˙˙Ş ŝŞ˙˙ŭĈ8 ö˙˙Ş Ĉq ĝŞĈŞŞ˙˙⪪˙ŭâq Şŝ8 ŭ8 ĝ8UŞŞU k
5 á $ Drop-Shadow D
/Ċ á $ /á Lĝ M á $ /ŭ 8 @[ HĴ L ŝü ŭü ñ
ü í í
ù ê &.49<=<80% ß
&-38<>=:4," & Ċ +7BJOTX\_^WI7%
-:CJOSWZ]]ZQE5% #1@L Ä &8HTZ\\]bkwu_D* )beD(
;eħı§Q* =e ]9
&Bh³Á¸oD$*KyİÌ 0V}zT0
)LtĦrI'.T£ŻwK'*MzĤȳ\3
>mĦÈ Bm£oD"
3QlxoV7 >jµµi<
Â
8d½ÏĊ˘rC 6fÄ +S¤Şd8 0BJE5"'M~ŞÀ·_2 Ü)Q³ÏÏ´
R)
3c 5bŻ\0 è
$"
/[¸È·X, Ŭ Cu¨ËÔż^1 2bÂ
?o·ŻX, é
6eÁ̸V* Ŭ8iÇÖĈh8
2bÁ !GxĤ½²W+ ê ;lĦÇÑşW+ Ŭ1_ÁĠÊ£n<2bÁ
$LÂĥZ- ï >p¤ÊÔZ- Ŝ,Y½Óʤp> 2bÁ %N°Çĵa3 î
>o¤Ë×a2 Ŝ*UşÑÈ˘n<2bÁ
%MħÊl< ì
;k ÉĜÉ j: Ŭ)T¸Îh8
2bÁ "I|ËÊĴ}K& ë 6cÄĜÎŞvD Ü+V·Êĵ_1 2bÁ
BsĤÉÑğa7 é 0YğÔÒ´P( Û.[·ÄħS)
2bÁ 8gÔɨ{O- é !,/* )K|ÍÓ`3 5c·ĵ˘uE!
2bÁ -W·ÑÓpJ. )7@?2" =iÀĊ˘rC!
@n³Ż`6 2bÂ
!Et¤ÇÖÏ·pQ;-%#%,7EPQF2 -SĴĈÈ°X1
*NzŞuJ&3c 3[³ÎÖÍ·gVLHJQZabXC+
m Ĉ Â*Kr·ÊÑÏĈğ°Ĥ
s[@' -Lo˘¤|aI:35>Ocu|t]@%
)JwĈ
.MpнĊÇĽ´Şw^C*
-IgveWPPV_hleT<% !8X~¤ × -Gd~˘ŞĴİĦoX?) )?Vjvyume`]]î[SF4! )A\zĤ é &:Napz~|uiYG4"
Ŝ 1AOY]][WSNH@5( (<82+# +7AIM î
!## í
ö
!$& ñ
÷
÷ ŝŝ ŝ? @ ŝ
ŝ
ó
Ç
!!
)
! )& (4>DE@6(
,8AFFA6) !(*% ,8AFD=2#
PI:+%*8HYgqtoaM6# ,=N^ksuoaM5 (6EOOE4'%-mĦĈѽ`4
# 5YħËÊ°
W2
3Y²ÌÍ´]6ÄĥnI, 6V~¤ĈşuO1 6U}£½ÄĥpL2%$.DeÂÁĴb?&&AdÄħhEŞĦmO5!(>Zy§Ĵ¤sU:& )>ZxĤŞĦnR<0/9LgݨcF- .GeİŞiLzm[F1!'9Nbs~|q_K7& '9Nbs}zm[I90/7EWiw~vgT?, ,@ViwykXDNLF<1$ )5@HMOMG?4' )5@HMNLF=3*%$)1;DJNNJC9- -:DJNNKE;0&%# !$&&$ !$&&%# #%&&%"
"%&&%#
ó
ġ
ô
ü
ŝŝŝŝŝ > A ĝ ŝü í
ù
ù á
" ì
Ŭ
" $0;CGE>2# Ä #+17;=><7/&
$+.+"%1$ .Hf
ŻŻmceo|޵ĥacgn{§şÀħa6 %A`y}kTA516CXrĦ§a?$ 1MpĥÊʸnfejt²ÁOHEHTlÁ¤wG"
<`yZ=' &9Uw°ĥĤ^9 )DiğÓÖ£fTJHN_zğ6)$&1Jp½Ç³U+ 1W˘jD'
7ZİżĤ~R. 4ZĥÒÖÂuR:,'+;YĴ 3ZµÈĵa3 #FrĤ
Y1 !@kĵɽk? (M~ŻÎÒşb<#"@l&LÈÂj:1Z¸¤yJ$ ,T
ħÌË°Q*"ExŞÊÍħR+ 1^
FxŞÇĊ£p? ?mĵ o?
BsÈÒżb5 Cu¨ÈÉĞzH"
+W
Cv¨ÇĈĤsA &K}ÇÁi8 5cÂÔÉ£p? Cu§ÇȨvD )T
Bu§ÇĈĤtB",U·Îf6 ,WşÓÎzG$!Cu§ÇǧuB
(R
Bu§ÇǧtC# 0[ÓĈg6 Ä&N´Ñ²L'!Cu§ÇǧuB
(R
Bu§ÇǧtC# 2^ÂÖÊ˘l: Ä "H|ŻÎ³N("Cu§ÇǧuB
(R
Bu§ÇǧuC# 1^Â×ͨs@
Ä ExĞÌÎħL'!Cu§ÇǧuB
(R
Bu§ÇǧuC#/Y×Ñ°}I" DwŞÉÊĴzH$!Cu§ÇǧuB
(R
Bu§ÇǧuC"*R·ÔÔ¸S) FyŞÇĢp@ Cu§ÇǧuB
(R
Bu§ÇǧuC!$HzĴÎÖÁa3
$K~Ĵğc6 Bu§ÇǧuB
(R
Bu§ÇǧuB 43:H\p|yfJ- 1X²ËË°X3 "@k*'@cÁÁb@&
&@]x{j[QOS\eki[E- "=bÂÂc@' /Nu3! /Gd¨¨dG.
"7Odsywpha^]]\WK:( (CcİİdG/ #7Sr0! -@Uhw~~vhU@- +=94.&
*7CJNNJC:.!%2>G
"%&&%" á "%&&%"
$
ĝ
ù
ó
ŝ üŝ ŝ? ¤ ¤ ¤ ŝ ü ú
ĝ ú í
ù- ë &-13321/,)! ùU>' ÷)8BGHHġJKNNI<) áeE(
1FUZWRNMRZeljX<
Äİf?
0LdmgXI@?GVj{~kI' ÀĞW/&Fh}|hL6)'0B\upN* Ém>
4[d@%+EaqhK) ÇÈ~K$ ?kf=
/I[XB% ÁÌ·U*
!EtŞsI( 3CE5
ĵ̽\.
Et´Şc@'".0&
áıÍÀ`0 >l·şĤeH1! á·ÌÁa12\ŻÀ½ŞsXA.! âĥÌÁb2%Gr¸Äµ lS=+ áĥÌÁb2 0S{¸ĊÈÀ°fL5" ÌĥÌÁb2
5UxħÂÊȽĞx[?' ĥÌÁb2 4PnĤşĈÊĊ¸˘eD( ĥÌÁb2
.D^zĴ½ÈÉÀĴf@" ĥÌÁb2
%7Mg²ÊÄĴ[3 ĥÌÁb2 )-$$,=XupM+ şĈ¤}U4 $@b|yeQB;;BPbquiP3 ¤Ĵ§xX;$ 3Mcli_TLHINV^`YH2 |}sbL5""3AHIGDCCEHJJD9* âMOMH@4&"&()+-/121.' &ĉ$!
è
ŝ ) p 8 TM ˙
R 8 gimp-text-layer (text "TM")
(font "Sans")
(font-size 8.000000)
(font-size-unit pixels)
(hinting yes)
(antialias yes)
(language "en-us")
(base-direction ltr)
(color (color-rgb 0.000000 0.000000 0.000000))
(justify left)
(box-mode fixed)
(box-width 12.000000)
(box-height 11.000000)
(box-unit pixels)
N÷ O O # °öÉ°-É >É öÈ 8Âx Ħ öÈ 8²8wÈ öÈ 8PÛÈ öÈ 8? È úÈ 8 ŝÈ , d Background ˙
P! , d PA Pí Pù Q , d Pu P P P P Pħ P½ PÉ PĠ Pá ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙ ˙0˙0˙0˙ 2 K % , d Selection Mask Q , d Q§ R R£ RŻ , d QÛ Qß R% Rm Rq Ru Ry R
R R é ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙( ˙ À ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ˙2 ( ˙( ˙ ˙2 ˙³ 0 2 K % commons-cli-1.3.1-src/src/site/resources/download_cli.cgi 0100644 0000765 0000024 00000000235 12537250704 024052 0 ustar 00bene staff 0000000 0000000 #!/bin/sh
# Just call the standard mirrors.cgi script. It will use download.html
# as the input template.
exec /www/www.apache.org/dyn/mirrors/mirrors.cgi $* commons-cli-1.3.1-src/src/site/resources/images/1x1.gif 0100755 0000765 0000024 00000000053 12537250704 023276 0 ustar 00bene staff 0000000 0000000 GIF89a ˙˙˙ !ù , D ; commons-cli-1.3.1-src/src/site/resources/images/logo.png 0100644 0000765 0000024 00000025373 12537250704 023655 0 ustar 00bene staff 0000000 0000000 PNG
IHDR , d <
À sRGB Î é bKGD ˙ ˙ ˙ ½§ pHYs tIMEÛ - Ĉġ !iTXtComment Created with The GIMPm° IDATxÚí}ypUEö˙'Ë{ Ë
ÔYrT &gqw$"ÇqĞïAYDE˘)EHHXÂê*ĉe'a˽ŝŭáïÜ:·oß· ÓŞ[I^^ßŜ?}ÎéÓ§] Áş 4444aihhhhÂÒĦĦĦĦ KCCCC&,
MX°4444aihhhhÂÒĦĦĦ KCCC×Îzħ*DPPP§çÑùR@ò>´§ğĵgŞ?OW_vV_>Öċòòò°uëVäĉĉı\.$&&"11.Ëè,ùg yaĠŞUĤÏ)ÄÄD½üŬäS\\ \sÍ5Ĉûä2äĉĉġtı\HOOWĉ-çĵĵ<¸ŬîÓzk ĵĝâÊÉ.çôôt£?Ê<ħuëVS[ó´í-Żü~^6>fÒÓÓc%|rssħjĠ*L0 ĤôĊĊĊXµjiĵĤ§§+ó
$Oz'Żġ1µùôéÓ1gÎvÑ˙iSDVVpı\×'55U :tH455ÑÖÖ&< x<>óxñĊŭÊċr zHü˘ııY´ĥĥúÏ{ï½'ÒÓÓw½óÎ;˘ııY´´´ÖÖVħeËhw||ĵ8x hjj2òĤ|}ß[ZÜn·xñĊMċiii1wÎ9^óÌÈÈŝ(**ÓĤMóÚÎviŭAnn×vÇÌ_~iŞŻÜşuĞ6mİî+WÍÍ͢ııYüôÓOâá ĥÍ3&&F,_\466ZĈ7dffĈaZZHKK ĤúßT ëñ ÚMXıııĤA1uêTñß˙ŝWÔĠĠqàÀ1~üxËxûí·E]]hllô9Ĝsrr|ĉ1sĉLcÉ';;[Ô××ÛN*·Û-²²²L$ĊeËÚÚZQWW' zè!ż&X\\8qâ¨bóĉÍ~-MV.snnÈÌÌ´ìµµµ˘ĥĥV|˙ŭ÷ĤIâí9sĤ8yò¤ÑNsĉÌñ+ 1yòdSZtvpğŬĤ²'$$+VúúzQ[[+N<).]*âââ,y ?Ŝ3*BÏÉÉ&L°mëììlQSS#6mÚ¤ +ŞgéÒ˘ĤĤF444ĉĉfŻêċrıÄĉÍECC1FO<)6nÜhİWMM¨ġğŭ4N°rrrLïàÁ˘ĥĥV ?~\TWW#GÊÊJQQQ!
d oùĤ8~ü¸¨ĞгíĴĴĴ,SċËe ċċċâĤn²ä"N8aÉÇñÌÌLnKXoĵñ(,,6%##CdggK x@îé§béÒĈgiiibùòċ";;[ĵġÖ[âŝûïÑÑÑĥiO8!êëëM¤(ÒÓÓm в²RĵñĈĈ{ĊĴY³<İ ò³cÇQ]]m,.$._\ĵŭöÛbÉ%ÊĥċikjjDcc£í¤·ÔÔTQ[[+N8! =*ŞŞŞL}ùúëŻ[òû÷ïW:ġ£]_.^ĵĜxgLL2eİ U}%ÊËËĊÑ£Gñ£"-ç_~iUUUĤçSYY)ŞŞŞÄħcÇDmmíû5N°8Yı\.QWW' ?.ŞŞŞDEE
(++ĈóôÓO+CiiݨVvÏVÈcÇÊÊJËûé)..ÉÉÉĵĈ +ŞŞŞÄÉ'-½M´´´Ù³g[Ò3F W_}µĝĝEUU1ıÊËËEqqħĜşuĞ%]dd¤X°`Aß|óA´UUU˘ĴĴL-[ĥÈÈHKÚ~úIÇÉĥµµĉĉf oÉ7))I ÷ÜsĜµk¨6ÊKyŝó˙´¤ğóÎ;v9sĤ!P{ŝYÌ?_ĥ¨¨HTVVċ¤sğŬ²:qâÑŞ,))Żĵò´
B'ÉĉĉfŞ oÔ§˘²²R 9rDTTTqĝa1pà@KşyóĉââbcÊVnniá>yò¤QŻ²²2Q^^.***Dee¨ĴĴëÖ3_TT$Ün·(//Ç ġġġZÊò!Ï<óÌ3½G mü]PP°°0455ĦmmmżĝJ#$$!!!ÁkŻ½fzOmm-.¸àôë×AAAFpp0,yÄÇÇgASSyPÚäädĵóÎ;¨5Ò˙ŭ÷¸è˘péTzŝ?ac AxîıçLeûĴrħ³sèÙ³§I"ë§"äÓĊëÇQZZW_}Ġh+´PP='N p8
ĠUg,.ÇĈĈ*ÉÊét DuÑEa˙ŝŭÈÏÏÇ·ß~Ñ£GÄx/½ô)ĞŻZ9x>$Nó˘XòjÉĠ;§?²T×[7c ĞÒqMDJŻĴqr%µÄ",D Óé´¤#Ġ&$Ġ?i)½ÇANNiŝŭû£ħħÑ3Ô&r_R
~Q²äsĝatO$D ¸tLġ£~Tµ+ĠK2Ï9oùĤÑç´¸Pı¨n7n4sa&",·Ûm|
dĴ:´I9 -&áÀĊ_lL ¨¤ğáŭ÷ß7ċÛğwo\¸ĝ.çÁ'²á0İ={ö İİÉx8ayäôN4èwU;² ÈU,^ĠÀĉö "+U~C"og644ÔĥĵÜŜ%ÀêĠĞ-ß;ïĵóLêµİlżĦ
ĊĦCcy× ;$İĞZŞĥQġ#ïKaq[,íŞÈtöìÙ8q"òóóM
_H jäİ%N ,î
;Êp(uïŜ ŬşuCXXBCCQZZŞ---&ğ] <Ż!C(ëħsçNJn ÉëHe Çk³ÉÇÓxK+K²JèkRòĠ\.Ż 9óôròĊÁ°äòÊÒ íÈ
UÚúvïŜmĞÚĠ÷#èèsğq`× . ʲĤĤbÔ¨Qĝé§,ĥH)pÂÒè ÂíJD$ÔònŬ¤'ÂêŜ½;zôè =zŞFAAíêFâ> X*çZËËËÑÒÒb²y3tÊKtÈ?vċUQ;ÒòòxËÏN:koZğòÊcÉĥ&÷§·ĥïÓ§ċ˙Ş&K˘íéK_uÇ /ĵ 4Aé ´µoi ĞTB;"ıŬ$V9ıZahPzċŻ2.SıeÛżD zMç/ĵízù3)ÍO>;èäáÙÌÜĥOÒç*c?½O:Ú6ĈŻw.[ĥ ÷Ŝ{Żí÷-Z믿 YYY&ûİ·
P£
C°7CÊ6,6nܨ<íîÏ ²û÷òGhÏÌĵ}Ö Ò:ÓVÖ
6ì9ím#}/n§³^D:Ï=÷ ÖĴYÈÈHċ÷JKKñÄOàòË/Ç?ŝhHê¨ÑÎ]BYµ
4lĴ"İ íĤ£&lŻ^½âŭŻşO?ċmŻŻÛĴ²nÈ!C°uëVÌ16Mii)nĵñFĵûîğ&W N$,à!n_9Ġ
rg ĝâ vWċĜĜĜ3>È˙WjùlÓĤM&{żŞ?U}yĤHvUÉ7ï ÀĤMS 2ÊÊÊäOâĦC/İzLv aY>[ırɨq²|ÀR%}ûöY şí@h·×Ĥ¤üéK_§
şJÒ6ßTêׯ zê)lĜ°7Üp´,X tĠ¤uÚÙğw/vïŜmĜ!
Ş&ŻŞUyß}Ĥ<ü è²O S
pM\ Ġ"WYY
S?ú£É>]W^y%z÷î}ĈÉjâÄ;wÉmBŜ ïÛ·/ĉÏ^xÁ~ŭúġĤ#cZ=ì ÂJLLTş <öĜc())ħ ìġ%YM8ï½÷eàŞù}û°wï^ħÜ×*¤òâX½ıaht cĉwŜñ{?G İìË3áËkŞĴ öèÑçsRSSqûí·ÒVTTçdċsZÊ:EÖC=¤\1gÏ˘˘"ÓÙ7ğA & 11qqq# J'Á7ĥŻ}maËÇîĵóN#wÚÔĠıjÊİrÓĤMĤĞèklkÂòs=üÊsĈ¸ċ[g!-ZdeeákAqq1VĴXa8ŭÉW-[fÉŬwßEiiİéL· şĈß˙ŝ÷_*Ëfï&Î#ĴİS§"..βÈ-_\éçĞ/`ŜĵyÊ< PVVÉ!ÌàċûġëgħÉgµtuĊí<˙ŝ÷żßݨ¨@ZZ 3fà½÷Ŝ3ÌÌL\pÁxäG +VĴ0ÎŞ<Îûôé·ŜzKİ~rÌn%âQ%bbb°fÍw1?íë8F{ñż>è¨MmñÒK/Ħ¤¤Ä´`ݤ,·Ûm"Ĵ×^{
0ŜÍû²³ÈÊ?> >lĝs:¨V)TJ§(a#== K,ħŭ^YY-ZÛnğ
ùË_0iÒ$ĵôÒKdgg#99Ù;ÏĊŜ½wï^L6ÍrŻÎ9991ĈÄÄ`ŬşuèÙ³§qĜÇ%âŜġ*ż¤% ğ[{Ż˘˘"`N Pċċ
^ÇÌ
^O?ŭÔkêĥÛnÛíĥHÙ<Ö?şdÉ$%%ÛSÒaĝ ´ğ.ÛĥmóY?àñÇ 7Î6Ê0I .4Ò$%%á;îûôF6,Z-ÒÒÒAòĵ!::oĵñFeI:ÚCµk×<7lĜaaáÂ
8|ĝ°1srr0dÈÜrË- ~RúÙgĦWŻ^¸PDXüL˘ló~ñ˙˘Ájç/$PĤ¨¨À_|aäòeIğwï^Û|éwU$+WZHR.Ğ]Ú7ÎÀ*ġ~˙P;Ée£\tÑEX·n LmtŬu×áݧÂÖ[EhË-T^\\ Ë
·ß~ÉÉÉİqU/>AAAÊ2úÓ6Şp8T?QÉôÑGHNNFnnEÒB`úôéxùċ Ĉ˘ELħµMĠO ~ t ˘
8tèîğï>Sx`îşë.Üu×]6
d H>OÈóİĞĞ+ŻĵK˘˘˘Âk^ 5k h
HGb
aíÚµ())ÁêĠĞu_ĵİŻĵòJ ;×^{-.ğì2
aûöíÈËËŞUĞlÓÀ
7ÜħcÇâK.Á# lÛĥÍkÚ^½záĈoD\\ úöí~ŭúa×]ÈÏÏÇêĠĞm%ĴŝŭûcàÀHHHÀ-·Ü8 |ÁFvi{ġê
#G"!!
Cż~ŭàt:ŭJÛż =^x!
K/½ÔóDħÁQ__-[ĥàÙgĊ={ĵöËċÂ)S0yòdS0ÄÖÖVCZ@xx8víÚ
mÛĥ¤yUŭFej
£MUDÎmMIIIHKKe]pâOúÜn7"##ÑÖÖuëÖ t\\ħ ËċÂ>ğïuuuhllD[[ a7ĊÈÒ8Â"ÒjnnFCCêëëñ? ŝıAH¸òÊ+1zôhÓÊÁW ]ôWkkĞ1PÉınûöí(,,Ä={L[ÙİİİGLLaÌ%UÒÑLùM4ÉT7 Ż¤ĤN<GXX.\h¨ŝ¤Ç´iÓW^y% ´ :t(^{í5SûÈéĝ!ñPĵġÖ[Óé4<ııÔĉ<ĝà>|¸Ç÷òï)S0lĜ0KÑ=üùçħk×.lĜ°Á7->>ŜĜEĉ¤iR)ĝÓéÄüùóMÈüP´]ÛtëÖ
7oİ~Şĝû4vïż˙~ >Ü mÛĥ!22çw êëëÑÜÜ;wâÈ#Ĝ³gÊËË Ë
ĝĝx ? ĈbÚÒÒ Ĥ°KÔn:ÜÌ)ñċÀ{ü°5
P"Çşş:Ô××£İİÉÄäaò#r$iÒz< <<ÜHËWOYĴŻŻ·¤ALùRı= iÑ ÇCÌT^
&%MÊÒ0Òò<İmyZŞ+
ĉiċ|y´¨/ù˘
µBB}ÊwŜx,)7ÔT?*#Ġ;uÊmCmJ $fô#
D
B[[Ñ&ĵïä
j MĈ:ÔwtU= GÑ2y¤Oy× ċ* L rÉù÷Èn´-,-ݽí R9ıó*M
"N Xŝ 'VN´ZSŭIKùò´\BĦ
ż7ĠI& z-ŜċT>JËWvÊ_ ò5âùħÉ.-´pÑ÷)_ j
÷< ĝí3<ô6/Ż KU?ıT?jc>nı"&>Ĉ4ùĝċĈwyÉü´ Ğ KE&ü´ş*'wîa}ùAÉħ( [*R,Ùù Ü0O[!GċŬM"Wĵ|[[BGÖétZòUı_¸ë!!!Ĥ`²ÔiÙiħIË'·`vùRŜŞ|U}ép8'$TkU})ç#ż_U?Ŝ6ŞúqòĦĊŜ)
=ôŭPS=T}Fy¨"ğj5°UBMK?.ûÔ¨È#e|çż_Ŝ·îi\P~'ĠABäşr¨a^×_%áÙċùriKVe˙ yó¨r}U1ÇċòòíOZUhy"rµ]öç})÷§,ĵÙĉü-£ÊöċO?ò´v Tnr;û
~İÑĊ ZÑOyeá zèXŜ6Ú¸ì²dĉÍÇE hv ×ò'Ŝ´¨²ĠÙċĵ~ÂíÈeċq*u'Ż´v>FrÙUïTIÍŜĴË*Ħżġ³S)½ġ£J3ĉú"ĤŞ&ŞÓ@Xvb7ñN5:Ż+ĵìÊí-8ĦjòVòì¸]Zğĥ·
NG]ŭí_ïSÁWÊX´ó?óĠ.ĈŞlBèı ĞàD:ŜÂwÔğüy˙éJÛ>ĊüTĠŜĵÛÛŝí/ßÙġ T;8 óAĈiYd;ĴOçB}&Ş&ÑeòëÒ°SWÏDY´Ħà¤=S Ñ_[^{ë|:ˢ KC#À Ğ:¸Ğ2ÜŻ^½ÚrU½ ;P ğ*ĵ·ÍĊĊĊĤÛÚ½ċk·yĠQeÑ*ĦF;޸¸ĞVBnn×ÎË
¤ĤĤ"!!ÁtİĈĵyó0cĈ !La½é¸*L7]Ç7êr[rká?UEëUáNgY´Ħ Qċċċ!++ˤÒÒÒLĈĥmÛ1µbbb äççĝ%:.MpYê7oéV
dgg#>>ŜĞŻêÄG n#YYY>}ş×²,[ĥÌ8pŜeÑĦán·˘rı\HKK3"|Ĝ]ĴûÁ `áÂ
(((°ÍcéÒ¸ùĉmm: ,À?ŝñeÚŭû÷#**Ê/GcÙY;{#
^§ısçÚÖ²ĜyċjY4aihĜ ''ÇĉÈ1uêT<˙üóJoğk×ĊO<ÒÒRËû,Y%áPôÓŝŭû[ŝ?x`Ĵ_ż^yÂ?ĥ# Ñò%ŬȳEEE¸ĝâ-e'|b9êv*eéLÂÒ6,³
&LPJU+VĴ@\\éÖ%ù?RFvÌ1¸êŞĞpÏ=÷`Ç Ĥ÷RX"Y²˘½zġR122ÍÍÍÊ£l ("?8O!{ÎSÉ$êı,ò%í-KgÚ³4aiġdġ˙üÑÑÑí¸TĦ¨ ={öÄ ~ûïżß*Ş",Y²àñxÔÔdÉ_NA (ìLPùRşs_=HY4aihHPİ xe)KÈ
BIDATYHK_½%ßVDêl×"IÄÛ5_Ŝ¤ßÊASeSkŻtRgù½ĜÛ[MXĝ% FeÜ.MWiŞÈßĦ)_Á%_ K]ŝÊï³lÔÈóèHÛP çûTŝT mè×ĦĠAÇwż¸tĊ# Èd%_n*_fħğt4ñ¨$$Î öEŞmzÚ äÄçíì7ÂRIYd@÷ÇĦ2ğŭÙDá+dòé,&,./iùCXòÁ^9~ß
TÙŻ¸
l^|WĞ
t%Oo1ÓOeâËĝöHa§+d&,³Z ô°¸g;7ĥÄ LV2aqÒ
2 #@È7 s"PŬdĵ:,Ú£~Úŭ~ĤKĈY%]ż J>çsLdòÎĉ* IV²KL"rÌ)N\3/;ÊË_5²#É#wuvYĵA ÍÑèà?ÈĜ³gé( wTù\Ù
ŝġġ ĈdÛáá@hh¨_ŜĞ´:ŝV 54: Ü Ği\BòEH2qİÈv ùğ|İ°4Î.ħiÓ&ÓÑğĜév·ż¨ìIŞż9ıÉÇyHòú5K+]\°4Î
$$$(?ßżżÏ°ÇO`ğm{Ĉ]!N·ÔùnW¸FFŬ (È#ĝöÛovŭ0ìğx8Iqû5H˘gÓĊX°4ş,bbb§üßĉÍÒż üUdÌÎöĠÙ] %_;ıiÂÒèÒ9sĤòó?üĠĠĠĥR!ÉêMe< >KĵĵC Á5×\£ĵâËşu)LFF||< ĴüßÇ lK v
|I*żF¸Ŭnäċċa J²:ÔBMX] /ĥ%Ĵüü| iÉĥ-ğßí¤0!rrr§O [È ¨§*ÑAĤĵċğşt K£KBĥı\.,Z´HùŬċËĜħcÊ0ÇÜĦÔÛrşĴĴ,$ĝʧ#§,ġZµÊ FĊËÏj KC =Ĉĵyó,ß9zô(ŝġŻaûöí&ÒâZv2ċOŝââb :Ó§OËċÂ×_m!"¤à²{< Ün7ĤOàÏNÀrQ;ÂR !²ğ=ZĈ)Ĉ ĴĴ,%i-\¸+WDuuµE²{tÈ#à /D^^ ÒÒÒ°yófDGG[Hß& TmgOŝïż˙>Fa2LKK³Äç·÷ĜŬàSYYi!GÊêÍŜ×Gs4ş Yİ×wyRR~÷ğßáÑG ĊŝŭûMi?ûì3|öÙgHLLÄ°apŭġ×[.Y%ÇÏ |ĝáĜ};ĉÏoĵcöìÙ:uŞ!Eݤ%">ĝ@Y½{÷Ú7Êñ ?? O>ù$
Lï ú(ĥmÛĉ½˙ĊÙäUĤqÖCÀD4·½ĦĦġġġ¨ŻŻGvv6VZ
ŞŞ*Û÷ġìÙħħħĤ£5
(--5}/##pı\^'3=ĊĊĊ9r$JJJù^qĊ¸ì²ËpÉ%Ħy¸§Ó°°08N|÷Ŭw¨ĴĴÄ'|˘|W||<ĝâ Vrr2vìĜĦL?|ĝpL>Ŭ¸ĴÊâp8àt:a<ŬğwG·nŬ °°0·|ŝR
ÄÄDŜ3f`Ì1xìħÇpûí·c÷îŬ(,,ÔĈÙ)i°xóìŝó1~üxìŜ½kÖĴQU>rä6mÚ¤ÌcàÁHIIÁÍ7ß>}ú÷ÚI kÖĴAII òóóħvíZŻċ?pà 8!mgşÌív£ B|ôÑGĜħcÊÊÊlÓġĠW8pà úġëĝĝxx< Ë£zŞRyLxoĝ ˙[·"//W\qûî;jŭv,ôÉÉŞµµN§mmmĊċ_ÖÖV|ûí·¨ĈÁqôèQÓù?R)CCCbED%OD°èïqĈżÈ;D2Ş°7rAù"dnşé&´´´y¸Ŭn0
8p şê**ïnÛĥ
B$&&l{ ĴûÛßpë·bÇ ĥjĞ&,./YÉv,OEwéiÉq°¸â
!0|ĝpjİ_ôÊ Töġ×_Wޤĥ655Ħħħ
ĈÓĜĜhÜŝ !!!p:7T/Y#Ħz< ÓÖħħħ7oĊo4Pĝh*Ŭ2Dġö×áÖ¸üEJJ
~óßàÜsÏġëû°4şĵE áPúR¤¤ş_Ġ%ğ?ÈqŻTôĦ2Ìˢ TĈĤÙT\wŻ·Ûy¨gıËêb{Â11ÂïïkÂÒèÒêĉÙżJV·Èí@81ÈqÜċüeRIYv7x ä'ğ)Pŝü"XYĊóFV*"É_a'UŞĜ o-j§ŬĊ¸°4şTCYÒUD]ü!/nÀ'5OċÛDd$áïñÙ9pŞÈVŜy$mıLï°ğ,×IKXí$-ëİB4Y}ù-İSTFzÙĝÎĠRYRTÙĈĵÙ²d¨Ê¤ Ĥ*ÛÑTduş˙ğ
Ŭyy IENDB` commons-cli-1.3.1-src/src/site/resources/images/options.png 0100644 0000765 0000024 00000065507 12537250704 024413 0 ustar 00bene staff 0000000 0000000 PNG
IHDR Ì A˙D cHRM z& ú è u0 ê` : pşQ< gAMA ħ|ûQ sRGB Î é bKGD ˙ ˙ ˙ ½§ pHYs Ä Ä+ IDATxÚìŬ \Í÷˙·$·L&ûġ³ĉ2aîZE,dsĉ²) 3Â0kŭÈ-fËebÈ%×ßd.M~É*ö#Kġ·³-
$ŝçŭá{vŞSêÜÏëùxÎ÷{Î÷|Ï÷|ú~ïïçòŭ| ިF%ġ=Z É@ͲdH wĉaH. M 0)/YEŞZ,X°Ôŝ `èS ,çÏ÷BŞ&& ^3C ` ` `jQ.Hj¤búŭÏÔħ²°è+Ïż £`$êzò$N>íí½ĥmû:wĥ£8ú裵tĝçH$ @ÀܸGĦĦQâùñ'˘GmĈÏ÷^ŬÖFÓĤĦ3gBĊ2kÖ|KżÑĝñe/èâĊŻK3%ċM¸ÒÒ.½ŭ+ôùçÉĠµ½ôÒ:r$-ÚN-[HSĤ Ħü£Qıa.ŭAîîŝTTôÂÂĉPÏöâġ-l(#*½ġÖl1àRÙ6·¤ÜÜğ´yó!şzġO23Ğ!~S£F
JmgYë-/MììŜ§]ğŝM T·nmÚ¸q×çŜ½ûòmPuıòĞM/Ú°á#:uµĝMÒgRS3éwè·ßrÈÁÁBBü¨{÷ĥ*˙>ĊĤ4Ïß*}ĝpgzï½%Èe `ÔV%ûÉ'Ħ"ĴZ5EVşĝ}úéFù{wïÈ>½AÌó7¤ ;D0²ĥn¨tÁ´|ùdzĝ8OĵJĵŝòË/PrrşĝĵmÓbßUÖgX``Í9öî](ËısèòċŬ" ä/^;w ÙVŻJ½{w,ó²Ö[^4lX_\²è_v/ĜMéée°bÛ êrċ}W½zµéÚµ²Ċ>3bÄÚı3@ÊÖ=>ĝ`e~_EòóïËusä2 @ÀTyLĉéÙÂżżM]ğĥ4iÙIŜó½IgÏ^TşN.:9µÓ\ŞùċkbúÇ 3ièPGñùÑ£]Ċú*ú Ûż?Ĉ}KINÎíb ZjÖT~~QÖzËKG _EÛ êrżŜ-GaaÑtêTĴ½/öUĠßW nçêßş" Ĥ":äĥ3>hs°ŞSǢÌe5²¤ÄAĞíÊ
D\ŭÇ%P2ċ*W;J?ÇÁ×#µĠ÷Ö A=ù÷Şúòò˘*\ĴġV&M´ŝN£Y³<ĊçbbNѸqËäĠĉŞü²\żKĞVíĠ ĈBmU² ¤ :)ĤıêÒÓ³ìK5¸êĞŻöiîëÔİÒċÎQïŜ ÈÍì~ZŜ Ĉ T <.ĤÊĞ"Ëû ×""mZ½Wáo5Ê\ı.Ĥ 8N..3.WÖz+&ÚLI× Pbb²/h-: Uĉ÷)ëûU üAK &QÂüì³ ˘&·q / ÷àä^²#G." t÷î}ñşboKı@ĴÛ@ı7-*Wġµk×'âĝĥe}-Y2^ôUËví
¨7ù^²\5ËĤuëŝÛZÖz+&ÚLÉ5ÓhâÄvQ´Ġîß ¤ô˙Pt3&H´*ĥ++ ÀPİz?Ìù"Îi`ġo§°°²ÒÑgŞot:Ĥùó·J=<ÛÇ żY\jûŭ÷ Q²ä _#Xµk× ?`r5luĈà? Z
ħd TPİ6L ¨³òIÙ# ) :%{lh!UĞd)9Ȩӳ ¨-`ÊDz Ĉ Ĵ1ÂĞ0ċÁRŬ BD§ L L L L L c$ ÉÖĊñ ÔİE òòrCÀ,Í{AËäí½ b' ^ZŝÎx0@ŭ²²²äÓÑ ÔE@q˙B FôMMCN? Z÷ĝñ$& T¤cGßbó5j¸ Q0 ¤³g/ò$ `ÜnÜÈ£ 4}úòó Ħ7ïÈß{éqF^LsçnĦë×sċIĊR4]ŜşÚ´ñ˘ÄÄ4rpOÍ{RZÚ%$>& áĝäP1
ÍŞUS¨sçѧnż÷òË/Prr:íĜ@ĥĥMĊ{RiRYݲĵuĠĞW]ğAgÎl¤Ò AŝH|L yFì#Ĥ=={Sxĝ÷ò÷~ü1u$3³²RĤĞXĥŞëJIı@9u½ŝzKşzġO$>& á¸}ûbÌÂÂ
Êßğ˙5jÔ@LפU^ô ` ¤
ëË/)*zDuêXÈßĞYÓòóïé¨qçŞĵ.@À 0h½IÓqäéùwg [:x¸?*Żn]ğÒÒfyëL öÙgÄe"ܳÛy^{ÚµkICÎ v¤ñuyevÊ[TŞÉjÒÄĈ(}ïÒ?ÈŜŝÚğwaħקO÷ÔcĥĵuìUk7Q 0\ġ
PÂÂ$ ` TÚ0 Ùo||*Ô"!áĴx§ùóçkġğ[´($//7L PŻk×:Ȩ/p&.¨+h"`ĴY3ùt`àX$4)aYYÙ(afp°90 İ.èô `|tzYIQQĤĤRzz:ċääP~~>ŝ# ÔİSlllÈŜŜ ÈÜ W@é[Ğġú6ÊhÑÂF#ĝèmÀä ùí} I˙˘I¨@mYtww'ahàÁ"n·÷2$èĥĤVĉşġëéóċË)+3SŝÚ+²ĴÑÚê7l= Â{÷èvNeĤĤGä=âÁÎ 2e
IGKc UÛ,(µ UÀÌÊÊ"/__JÉ>>ÔKVZ°iÑ{ ëVv6%ÈċÁ
èrz:M:"""(,,lmm@:ÂÁÒKËi(M£ §NĤ·ú÷§\YiKĝúC5Ñ&*z^VŞ "+QòçÚ3()):wîLÑÑÑÔ[7$ hF{Ér°tvqÁĞ]·;Gn^^PeN b?j# yyyäèèH'OD áLċ%wêéäêJĞEI ş,ĴÄŝÔŬŬ]t"ë/ÛÏ2220 `s··ĵdıèÛoİ%RÔk)xżJ"x TÀ Y³Eċ,AcAsYt´¨ıà6Íġë×#Q Àp&ċŻĝòK1Í |(Ü@Ŭ¸zÖ/$DLQaa! #`ò |%_:½a4;ñŝMûdû_Ex9 L Áñuè
[yO ?F"TÁ Ċsä³ŭOŭĜ´iŭó˙DQĉm ?4K¨èîñ ĤêlB˙ĝcÊüñG²í>\ħì{öTé³ ;ÒĤÔT1íR£Ċ=y½TĊRĉêİS)Jĥ˙qµlÉáó >L³gÏÒiàü#İUğ6µhÓ>Ú°ì:wÖÉö(ĉmm ?p Ñó).#áê1S ÁçÊùó´êiNXÈ<ĴÛâQ£(?˙éRgÏʧħ£Ğ;ŝ´ ²ôĉŭÁ xÚßß_.wìĜ!ĉÎ;`&B1 ?pÖÍE_Ê.(ĉmm ?p Q?µVÉĤ§_Ïĥ&|ż}Ñ"-;@Kgħ#çÌĦeV=âèjF- =ĥÌKıׯ;#.ùÌònÜ AA´fút
ñó£;7o×½dgÍi4^ö=ÍÓ´4M{iżğß\ğvM\jâííM Ê@<"JĤÇÛoÓÏ?ü ÷yŭuw&ÈJeċċħòòìŬÜ\Ëóçx^Ùúó´·,ċüöççñ
û*DzĥGÙqC.ï·á˘£fNÎmñÌŞ df>;TÔgäHQ](yáċ)=9d%Ùc§ÒÇ7³Á²ŞPB?ù:öîMcäıaĠWnÈĈ3gÄ8ĞŝQÄ+&ö
dû].]èÜıs´Lv9s&[·N[ñ@[·nUúµxVcbÌËĊÇÇ?=¸ĉċ+¤Kĥ¸;IñċVùċçċÌÁm{ñß|#QܽKfff´áôéróXyy8ëĤME Ç8²jUİġ×=Ky;,0 À`J ùÛ û÷ï/úo°ìÇAo x§ ~;¸fıÖŻ_OnôÛ£GêŜ½;
8P è#^=|ĝ0%''kÏıw`äg.-Jc ;99
URPP &WĊ*ğĈnË-ÔşukştéµlÙ˙= Üd´{÷nyĞKE
£q˙ @ÀĴĥàà`j׸@>;5jġíÛWô &|ÜɽWıĤx{³òq\ĊÊ#Qqm?s[$ `Ş]`` xŜݧżûî;ħC~JKK£R%.Cí)))âZq kÂ$~~~ÔK1ͽXıwêá¨I^YÒ'OJ(ùbŬĉÍ"i ½? ŝwòrĝşĦí Á8@ĝf ŜyG>˙ZÔí·0 ÒpYYÚż]$& ¨5XşşıÑŬ[·äŻq°ô? jÚf¤ uàjĜ>²`yG,ùĥ}}ÇA˘QAÀ µK÷!CDÉe#ôâĞŻ"aÀ¨ J Ô,oçäPfÍhe\ n ¤>\²ä`ı:1Á0 JKİI, JR%% ` (8> ½ċóízġ˘#JFçÒU× L QQ'Í İ`(KC.y>yüjáb@À*((x UÁWħ×\jÔ(6˙ÂË/ÓÒİċëŻëŬoġíĜ6Ĥjġ;9}âJ
`ÀŞ3b@¸BAcĈG6PÛîŬġê7^<{˙hC] èTĞN(`çNZĝîğò×Fĵô]ÍÈ Ċ£GÓıs)÷úuñşĴHd%?wí
˘5Ó§S Ŭıy³Âu°ğıı ,>ċùëJÂÒ³·½=ċüöĉçñeÜPÑûvvô篿Ê?£Pĉ
oĵA}-,Ä÷ÄĈ*-m5_Öo 0ÀquìWŻÊçı6=9vì Ùc§ÒÇ7SÁŬğdffFŬ6+ôO¨cïŜ4& @ÜLYIµĵu0 £ŭŭÉşiS:~àè 4eĠŞbëçĥKĊêÑ7
£ÒÛ&ÑÉï£.nnJb)şÛôżèhr0NĊÄP÷AäïûúÒ+WR{''ħËĵ½iÇ
*§YYżP ùä8t¨Z²âħÈHñzvVµîÚUŜ_ï3r¤îíéIßW¸Ì""D a\µÌóÊÖŻ¨ğğ;Ó ü:ışÊ£²ë* ?ĈĊéÓ²ÏôThó
=sFKfß³']ûċJQYżP ¤XúŞLG÷ïSFÄtMssz pÓfÜğ}[ ÜÌ-,èaaĦJëàaü·ÍĴfMëWd×ı³hÓ,zĝPTÎ˙Ï*ü \ú
ô½mı
ħĞcwí˘GEEâ; +ĥċŭ@À £jĵ&ŞPŝ÷óóİPÏ5nĴôsġ6_úÁǢN ÖÁÊËĞôïáÒì·kÖĴ4+êòŞdyÇ!CèÀúġòÒ¤Ğ`ı·)W/CÉß^ß ` 2N˘/||hî×_Ë_³upí
ËĞ]Kâsò!Q]ÊU ÈTYë¨QtŭÊúGóĉ˘ŭï+Ċ~%ĠŞ][Lk×Ğ'ĉ lFÍ£òIAż÷ߧu3gÒË{ŭ\RM[ğ˙óbÛ·iSê³|Á'ŻĜÛSü7ß].ŝ
LħTĤì:LîñÙ²];7t¨èE[Öċ+>û˘BCE)wÖáyUÖáD6oĠÜ{vĈşueß Zqô¨çkOım´££Êż÷Ż.ë%>³ 2Rl;· ?^KâtáïŻ× ÍÛ½n\ğVéß ` TİĤŭÒ%QŞZ¸woıµjÒDôÌ:·mzÎUáĥyÈJüP,
żÚ½ĵmTĵl´`ĜÁĊE<$Û32JmDDÈJ=Ï.k)ï7ĉ , è
Ġu´xÔ(\ş& ŝQèíŞËu~ù2ŝ9(a & & & & & Áe% P%|;) SÚï0 RZ´°A½Ú0@/yyñí(++ :
ÏöCL û é
D ×É·˘Ó & & & & & & & ` ` ` ` ` ` ` & @eàÒjPTTDİİİN999DĦN:dccCöööäàà@ĉĉĈċĥnŬJYYYĝN´hQH^^n$÷}û-ESÔ˙KùH(?xÖMîîî4Ì ,İaËäí½ ˙P9mMÌ*Xżn -˙üsÊT8ĥċr°µ%ë
İaŭúH$îRÎíÛ) {"#ĊK4eÊûMYYÙòéħcñOÚĥ`[İŭS/YäëċEħ ò é3`
îĠZÈ ċÉuöÈö
RúċË4uêT °°0²l^ó½ML=uúÔ)ê˙Ö[+J_LDcúö%ó58 ç§)CÎk×RRRuîܢ££İ[·nH$ =^²*Kgg,ıÚġÜ-äċĉ` Uĉáä$ö£nmÚP^^ 9::ÒÉ'0 ĞaıdÉz\;u˘ÄĠĞEI şĴ,-ĊŝäŜ½ğèDÖżÊÈÈ@ `&ï1cä%Ëo-"Ëşu( 6\KÁûTÒôġġÁ 0
ÊONm,A°ÍèeËDÍ·i_ż i8ĝ,˙Ë+Ä4wiÖ¤ 4ĞgCüüÄtPP"Q 0
JÀ×Yò#Ü@Ó¸#ïoÙÙÙ´oß>$ Ĥaà|_gŜ° -
zş˙EF"1ÔÇOôz}P6\İWÇòpw%0e<:Í;tġÏ?Eµôw}FŻ·lDÌİĞWSTT¨5ÔáóôK
bó/ĵü-=¸Z^ñŝI>ŬD]t!STùûÄoG_ÚşİĜ{gÎÒú×SĉdÛÁ>\ñ!Ù÷´Wi½ë0µ$RSĊe$\=fÊ#ĝ¤\¸@ŜËÑîyó¨{ÛĥôÏ?Ó
3:µj
E¸,mSeiÏû!3P/Ċ`r!ċ W,.[ IDAT˘6|Dmğ·-÷sï¨ \+rñìĊbóWÎ_ĦU ˘9asȳÎG-ĤÀ˙Ò+öŻTj}
*Y%ĝ#ÌÁ +S§ĦsçÒv,Y×ÖiĦ·7%=+_ĉu JLK£&ùyy´s'M_³üBBèĉ;òek¸?ĉ_12^ÑÓÜ-[èznI§ğ´ßIû!hFĞN(`g -|wĦż{"#(Ä/ÖL_#ĉRÛW˙$ö>ò@;ñÔע/Mè8RbSÊ,Ċ5ŻĝúöEÛi´˙h,-3Â
ËñÒşq^L[ĉnĦÜëıJק¸Ŝĵy´3h§ĝ-üîÜ|½ÚxQZbwOÍ=éRÚ%ì ĈTÂĵrċ
Í?_kßwüĝqñlanÚp-yÒP²úĴ$nffF§7lóRï )`ÌÚCnÜHfÎ,÷{^~áJ òÏlŝĝcMwë
Ä3ß*N x
µhÑ˘Ĝkâ hóò>-îNR|ıTñgĝ·ħ#CĈuSk:~à¸ŻtÊŞ)˘ÔĤXĠìL üÚ;µ§ôätZĉ½v\ĜĦr ·dµéÑ?Ò˘>#ûêİĞċó\}Ìß°#bvÄĈO7ÒÇ?Vş>Iè'ĦÔħwG0FŝfRízµéĈµ´ñÌFş~üùSÄDCCí7 ,ú÷ùċì!JJìIÜÓ -Jf5jùÈcÇhìÙbÚ³woúË/+ ?ffÒPGGħÑ4MV25ċÉw7a˙÷˙§ġq`òtâİĝZIİİ
=,[Nù@×
˸8ĥfîñvZ>qıÑPù4·3^ûċZµ÷Ŝí{dQǢĝÙ >ü;Ì$ÇĦTĴıvi!"`çXä1½ñi^ìíÙüK0ıì4ÌIĴKñ <`ò-ĝ ÑĵysqvĴÍĉ#G¨kŻaQ ÉUнoßğ'\B/|ĝ°ÂġŜ=+Uñş
dóĤÌúÙ˙ú׿4ö Êò0ÈÁÁVa97%ËÊ;+ŞÉíÛĊŞ4Íj*oħâŞÍĜ]ħô¨èĠ4ŻIÎĠúŜú
ëSÑ"$%<ŻD Ü@
=Í#ü
*Î# 9(* ÀßF0%\¤Í*Ù;wùÄ(ŞÒ´Kġċy~½,|/ÇO YôèĠħ°PşbÚÖ43£üû÷ĊHJüzç3étÏyÖîkmmĠ<Ċó 0Ĵ,³½îUbı"`Z*,g¨¸ŭĞ;ÀUág¸
öÍaoÒs£Ö][ŞOe8èİ˘ÛÀnô}Ä÷Ôï½~ò× îş Ŝ÷óïS]Ëşb½üŬŞbä&÷X¨îDSŻA=·{è\SÒÏ&eV }:ôf³VÍhöĉÙ´ròJÑVÉÛş(^ÂÂ=v[ĥkIóν{oÜ]r}Żóvr/^Î<êOssrww§Ŭ´/)Ĥ{xlZppĵQv:İ]SÒÄÊJôUe]żíÙóôú?Ä5Ż{.4ù}oÏħcâ÷? Z ^]£Èm³<+ülâ!Ùħ]>ÍANħÇéßöZÇtñPÄ×ûa]ÛöÇ?Ä5 ÷Î#ëSÜNĞ&V˘lEék7U*Ù2 {$7 :$Úâ@sjת
DxfCtôÓŭoĜ0µ;ĝjµ ¨WğĤŜ% Lµâvèèh²´´J8úùĦzÔĞa gΤ¨cÇDäŭÌÎÎ i¸Ŝx
4Û':Ħ÷,Twé0y2<{V,q+/ =ë0+4O:EŜŜŜbÌÍ÷,Ħeááä3`¸)ß7T5|%_:½a·Yr5,J F
Ğgı¤ıiÓ&Ñ&ÄÌXğV<ì_}U ñĈ·fâñTA=¸Ïĉk×Äh@Ö
Ôößûë/16,wÇ#ĝHĝÒî
Ë |Ì
ô6rÛʸ h{+û¸c
ÔşĦÑ˙f]îwU0~üxÑvß}IQQQ.; Ĥ_ĵÄÑ cii½ŭ|İyzz|¸]Ü0O m4ġPÚħ4ú½û!ĤÍeñ(**˘ÔÔTJOO§ììl*,,DİèñÇârß˙]Ü(§ NZµï>}Î;'Jd;wÖè <4$yy|b V×WJ#ü¨k¤§·ü²e*È :
Jo=i ÁÛ8ùŞáîïï/N4rrr½×Ż_? ĤÖúo˙ònĊëĉX]4)//Odŝ'O- ÏĈèÍÈÈ ĜĜXq²ÁCpÑĥmÛĞĞĞ8[@ŝ@ŝğ Ô3:ßIII/^ç¸t@x÷ŬwĊċ\U1N5Ğñx. ? txÌŞÎŭû÷íşb!sĤçÁÄïÀ!ŬB
4Oéİğj?0ÊÁĠG ĤäädqM*wdıqxĉ³ai,T'''Ñ+ÔP{ &TŻŻ/íŜ½[^
$á³gé
ħ ùùglncáŜyÜÎÂÛÖÖVĵǽġĝBâj (ı ùùÊF111Î(
·³¤¤¤kHùzŻù{~~~ÔK1ͽôZ·nMb;-ÔĞî ŭÒääÍċ\iP¸w£££Ñ˙N?@7 5h"vòv&f ìï ïÚkôv HPÛ7§tÔ=Ò*ùcÀ;ç×:ĵF=ŜFŝ ġcÌÊÊF ÓĞ+Ŭş{WŝËùù44ĠA#ŭ?\Ŭ\éîżóKŻùÈ ŝ İm¸ f%p5[>tëÎ q;Ż1}û"Q òG ·>tçÖ ²iaC}Ç qAÀĴÄÁ`ğğ(Yr°< LŻĝ"ô Wír Ssŝp â.J ,ÓŻ" ĤÉËÛ·İY&·r%Ù6m ôÏ ·snSfMheÜJjjüĈm:ĝpÉeâêĠ˘ wá%ËĠĞE ÓR \²D°ĝ;H |8HrÉÁ0MW3I%KİÍÁàïü!,6KK@À4AçÏ/vÑuŻvíhç#Sg× É Y²üá-o×Ğ ÙY:èŞë? ĤEEEW,Ħä Ĥ?NW,ĦäYuO ?Ħf5z½dĈä|Ç-÷6gyıUmxĤ..:YNŬÛWÏŞ{Ħb<ÂO`` ÚFú)(x yħcË}Ì Cn%/ËLͤO|BßùVéúż§E#İ´-ërİñ÷8 ĠùŜÊ,ïÛÑW>Íi¸7;4Jú #ĝ1ÔH?U Á'à Zzp)µ|½eİ÷ ÑĉÍ´öÄÚJŻkÈ!ZKSu}oܸrßżxö˘|zêêİäçè'Ò½ĤyMìĜ(a èɢo_ê8aĊĤ¤Tk}
êĠ£ëııä½l}ĵaŬÈËĞö6^új#;hġŜ{^íġñ6-ÚÎG§22Ş]M{÷.GD_HM_³FÌáĠW˙$ö>Jß?´ċÏ5~ÒëRVZğ{"#(Ä/ÖL_#ĉĠŭŞó½ÒgıÄêÙÜú÷ĦoL¤Nü$OzĥjbEŬt£è-ì ÓĝÓòÉéá#² GWŞÖúZżü2 :y6ü1
éĠŝ½ysµ·10,fA{.¸ÚëÛşU ĉ°gÁʸz^¨ĉ= çnÙB#ûôĦĠS§Rï ÑÁŞ´1ÒOeKTeĴ 8N=ġPËşĜı[¨ÏÈ>˘tÖħwGµtDÒÄ÷.ħvÑ˘£4}ítZùÁJßÓó| ;5Ĥñ8JNíÛ?ŬÁííékתµ³/Òpgg2ĞQş·mKqqĠŜĈŭÉÉ4ö·ÈŝWè Ġ^_dByöî-ĥqĜĉêàßĜÔÚZLsĠ¸:~³İÒôH?êtöĜYjÛ½útD Y7}ş qÉçµrbPÉïíäÚRbSij mJŬ¤t9N´ciĜİumĠ¤ĜċɳúÍ;whWl,=zDĉ5k³CµÖ÷àŻżÈ²n]ùë T{ïmS×oÎÍÏÁĠĞ][lsuÖÇ*^Ó çvHħş²˘ö:ö°![+ŭle×Ċx¸>ĊÏĠ4Ğô6k{Ç-GÑaÑq*öŜK>}ĥñrÚpĤAz˘¤äUŜ|?÷ umŬ>8гġëÓë×İù?ŝA<óĠŬFn}XTDĉĉjùÍü[üû÷+àÊúÍy%.ï£jÔİWGtüáÀPò³]Ğß°>EċEUkµñ½Üfë9ËS\Fr*ĉ-·6ŜPj9N:Ĝħt§ítî ġîÜştĦÓ§İMóĉĠZ_·6mèkY%ËÖ=ÚĠµÚÛÈÛñŭ÷~ù²èĝS]²Òà1ÍĠ½ĥĥĠZß(Ùoävàĝqr1; ppv 3ßQÛú\GıÒġ+O÷#n á˘ŭ¨²ßûA×(-1M\siŭ˘5ċŬxÚħŻVíZô àïÔĝTFĤÑ\°Be£Ĵìl?p (qUÇñ~×{]ş^2Wím\2~<½5{6Ġ0wT{}|MêWû÷G` Í>ĵÚ½Z||hóĦC˘j{ŻCÀ4 ŬŬğÓ¨ÔĊZÖçäC6 U¤ı×siĈşż÷#2JéħşßĞÌ´5ÓhĊÄt1í˘hû Ú $^Ùò äO+xzÂ| YtüL£á"+]òCħ}{µÖwçğïÄó6µm#÷h½ĝġ×j[_£
(`Ìù|u×ÍëċéɤúëO^mĵèĉ 7İñ?Wj]ÊĤ4j Ş:8~ Z~CeżWÙòÜÑ'ôLéĤé âÁ8M~ŝüVûa'ÒTÉêPíZµLj}Z'OŬ#ŭh_ϳu³Öiüğ·yŜ ŝĦÒ_|ĦòPÂ4M
ÏÚüLe}Z'OS#ŭhópgñ4îjHü·ùcgF tLFú@À ½eH#ŭ ` ` ` á²ráRŭlê¸U!íwJuk OûĦ~m
&èĠ~İCÒ(èş êGZúÖç&ûkü:Ì
ÏöCL½
Ĉ|Ġ=ÒòèVĵN~ 0 #ŭ `
0Ò & & & & & IÂÀ FNŬ#ŭ `QÒÄH? ĤU² ~ 0@é ÀÀà²5(**˘ÔÔTJOO§ ÊÏÏG˘P§N ²ħħ!{{{rpp ssÈrÜ ND +-ZĤ!Éo÷}Kááôߨ˙RA~ÊUğNmrww'a 4x`L
3X &oïeĝÎi;h"`VÁşġëèóċSVĉßgĜŻĜżBĥĥÔş!ĠoX Bá½Bşs2S3Ċ#rO¤xpİ3 ĤL˘
WħçêÊÊÊO
2hĠĥÛJízĞ ĵ|½(!6A $ĝ ^{M $ëVö-JĜ@7 ¤ËéiêÔİAaaadkkĞħïĠÔH? ,½ĉ{á : zêÔéSôV˙·(7'W"'}1úéK5Ík"q@%ÏÛŭ{׿)#j×M³6ÎzÚÚ{Ŭżw_ìß-_oİòrċċ3ey?Ûu`ŭÊü1FùÂĤ0´z|üĝñ§c âżgTĈgà üÚ;µ§ôätÑw\Ĝ!Ŝ+¸[ JANoó[ĉnĦÑŝ£Éşİµ(İòSV= pĵv½ÚtÚ
Úxf£[ĠżĤ^ÔÀşÍ7O0-[F3gΨ(÷ìÙC³fÍRú^pp0yxxi £ä@ñññâ9/ïïÛÓñ ×|wâËçü<ğŬ'höĈÙĊ^{áèÍ éOBİcï4&` ĊìĦn¤f÷ĝĤ Yç³hç/;)-1vħz êAaéaòŭ;âJÊËÏċ ŝÌÖÀÔÎħ ½ ÙuĴ^°B3ieġ÷?G*Ñĥ_Îüb²;ÔÙm`7jŬµ5}üü=.9JĝLüÚ/×äóÙ²,/ÏIGÓÖLTùY
|í4ÌI,ËgÇ\
w7 ŝO°èÜó믿R³fÍTŝ,Ë+Wù0ÑIMÍOs°\PĈ@×
Ë
E0*ËħÈcòÚÛ³·¨Ĥ´?siħKú¨÷G´`ÏRû·ŞËÏÊÊ; "żñëü>]0Éí4ÜvääDÎÎÎZ-a 9r^ëĝÉîċîÜĵCħğbéQÑ#é ½ŻĜĞŝÌjïR|iÏ[?/e
İ}ûö´dÉ8q˘JċRdy%L²@\ÂäÚ
Ĥe÷äfBÂY£l²àÒßŭüû)á@jQÇîŬ'?ä}_<~ô¸T°UÖ^Ġċ*ÊgÊòN~n|ûĝ;ŝz2İL KmVÉrg
E1D2\5ôĉ°7EÛ
&ıŞĵPT^îäÜ8e?~ĵhżÜħcı¸¸ûY.AJÈò(ëÄó 0Ĵ,³½îUbı"`Z*,g,şè* ú{÷żĈmÜż=cğĜı2˘úÏ$ĵĴ`9öpÛ*KŜĤXÂÔEÀĴoY_4Ĥs z· rè)Èi3pü@q&[ ÑKĞfsŻçîúÙÑaĊÑ&ĥ|éS×_rpS~~>
8zöì)§Ş¤>\
Ë%K(ÛËv/^Ŝ_}ôh'üWçÇtr î,ß7yßOMÛx^ ò{íî˙jżè;|ĈpÑÔ§ËqŬM` ì1żÂ;Ĵ;Ğm¸;&ÈXë×½;ò]Ĝ !zİq}köÑSż%ËoùFĞùèïċÊÏç\%Ë ĝàìUáñ @½ĝ îmŻê~ŞêrŞÄCTÉÁcĜÓ É#n è
ÑâyĜ°aH =YÁîü\-{dç$h\Ò$ş~lllÄŝ /çlŭìġ˘m @SxÙO{AC 0ġwàKZ¸ÊŝsTjt¨,ò?h>ŭġ+ġêĠ&MD@À4tçÖ q;Żcú"Q ?ÀD `Vâ`à>Ä]9óÁ ĝH0½ĝêH ä0¨ÄÁàvÎmjÒĴ [F &(:03 V'ĈÁ &GúAŝ L ¤ |À3"Môü p5tĉ,µÉà` ü àüùóĊ.şn×Ğ Ùy¤ÔrÚġ LşGú9>K?ĵ? ˘˘˘Í+;(Â5è3uôuBoóÇÇO¨Y
üÓS[¤ħ"UĦn%gÊLͤMn˘şÒ)C´ŭ÷óïO{ úúâ×ĝgòÇjċŞpİáBqOâ*\η£/mJŬTéġÇO{inĝ\½Lsé÷/ı;PGìúŞ#ĵ@K.Ż·Ôú6ç^ÏıCçÒ ŝÀ?ô2hÒĊ³+ŭ˘E´9`3=ħVïÓ|êêİäçè'ÒĤyMìZ 4p&ĝçĠ?E Ż˘LÊgµ ğ},íBÊĝĈDêkÑ&t@)ħ)âu×}(-1MĵĈònäQX`- ½~ûF½:JOßŝĤŻN_l\ê;ùğâ"âÄwh3O5?ât5ŞĜ·ÌŬ"Nĝ¤}|û˘í4oè<Ê8QĴZ·Ĵ|"Wz{"#(Ä/ÖL_#ĉ9´ċ@Ï5~ÊÛĞßoĠÄş
èFÑ[0à;ĤŞÊŞ>şvöµO\Nׯ\§W|(/Ĝ7&/LG !ż?Z5yx½ànÑÓÄ^V>)uòGÖMĊ4 y^³ÇÎRÛîmе½ÚüŭĵiÇÒ°óè Ú0ĠXŬ¤J§ÙgSúñtqܢm êâÖ
^ħEĵwçĉ ŬK ö gùçÛ+x9s§˙şşuéŻİ´Ó/ÓÏ?ü,Ï^y[Àĝir¤êzp˙5hÔ@?xÖĦ(?7_~Xğ^íbûxyùDĠ§?Íj*/ <,|(ÏOUŬ^mŝ~ŜVŜf@À48ŞIEÜ Ĉ
¤ŭI´nÖ:úüçâ½eŜËDÛR¸DúI¨ÒuX6²íq¸µĴAIü]\ÂühŬG* Àij¤Ş(Ù~Îû.ï|âÇïIíü,Äû¸Şù¤~úUá6ĠİWGŞş½ÚüŭĵE ìĜ:*Y]İÈ2'w%;t:ôî J§cNĞUÄí2ûÚ'Ĥ÷'SĞNTúNŝ.ŝNK&n§örF;şÙuħżÇííÇ ÓG}[ÔÜxşPÌù>ÎËİOjĠ%/ırŭ·SÎpĦtû¸zĉû3ĠÚ^mŝŝÔĝÔ2KĠi2D. ¨(qÍm|fİÌĜÀħ˘#_Ċm÷ïŜGâAx¤ .aò³.%VŝüiÜëèĠöŻÒk7äïqÏĠíZŜ üşt
ïÜq-#PôUìáZ^>Ùñ]Ì'ÈG(.&~H3Ö)ŬŬğÓ
Á޲½%{Âjò÷s îĝ:(è ÔŻ²Ġ´. ÄC²=cğÒġqÇûsßÓ|@P6JU·şGúİ,n¸!ßóÛ ù4_/Ìmĝ ÷.,µ #W £Ĵ|Â<Ĥ{´îXWŝúW/şùÇMjüÏĈUÚŜjċ÷ó6ŝŭùö Ş8´ùċü#J|vŭÑ(`¸
U׸K£ÜĈ˙ï]˙Òö>oóĵV~??ĝâ ˙ Şâ; Ĉ Ĥ0F/ĥÛöùQĠí ·hV~ż˙6ì4:6L L L A&Óç~ 0@oèÓH? U² (aVOY·0¤ŭGĝáÁ ¸JKÈ üİ6 @ öêP÷H?-FBŝ ŬċL} uĠĜ ,ġµìŻ òè0>Û0ġ*h òèx|+:ŭ ` ` h
Ú0 Fú@À `¤ ġ@, & ġ\ÂÄu Pi¤ ~ L L L L L Fú@À `¤ ġ@, J À#ü \%ËMuàġaä -
eû³& ¨4ÒSGĠìÖÉÛ{tNÛA *YbÍO
Úĥ`[İŭ ôKŻù^HYÔ6tú @À @À ´a9ô *ÀH? ê*Y L ày¸y 0 ÒH?ü úçÉ'HL tŭÊuÚµt
/ §`ß`Ú´îçßWùó.5\äÓ }+µ< ` /ĈA/ĥ|Ŝŭ.ù
ĝÑÇiûÂí*>îI|úâÙHPL t6á,9wĤf5È˘½?÷}:°ŝxï}ğ÷)ç· 1ŭçŻÒFµ ×Ä<żŝ^Ğ÷ä%ĈÏ\úĵÚxeÒÓċßgÓÂf\%Ïĉâq)íŝ :ËJ LtË/Eñññâ9//_aılqwâËç|
ċLÍ[cߢ=Ğöó˙|^ë½l÷2}wç;ñ^·Ŭ(%6E,ÇWÛżJç8OÍZ5£ß¤.n]èÚ/×ä%MR3,0FÌ AğĥĤyCçÑ ;ÄëÏ5~.ğDğ/ïĤËéÉ?E\À ĤxËŻRS3;,[Nù@×
ËO%ÊûwïSôhş}ó6yLó Ż·1:,ZÌÄoİğ{wúßá˙Qż÷úÑİSäĉċF{Cö*]oòŝd6j×Kv!ċ9q%Zŝ?Żŝ ÔMÙH?ÊFŭáfBB98Ĝ*,çĤdıTÙrgÉVa9SÓ Qí?ZL?*z$W3ż˘à#ÁÔɵ½$Ŝ;ufnIëfË9MóvÏ+s½w D°TĤĴ× ÔDÙH?Ê^yVV
ËÙÈ^÷*ħÜV0-35nġÜ(:?Zĝ8q{ĉ÷÷ĝ5'Ù#'żÏCï6°[ıŻ^zTô°Ì-phÖGèô PIïL~vħ
îë(m>$˘¤ßûŭ(."zŬSÌ÷xğ¨ní: kİuĠŞ] <Ó\û}Ä÷˘;ŝ & Agsµ,·E˙x½è3yĊdùûÜiç\Ò9rpvóÜ1(TµíŜĥÔş&|6Atâa§²| G ì
@Bëû *İe]rà^ĉûVMĴ(*/J>ßÔĥ)íùm|^ñ:Lé â!-÷ġĊŻKOqyeó& & & & & ` ` ` è. *ÙVĈ]L@{x@÷[Ù·ÄíÂZĥkI
bżCÀ }Á²#hê´ci&ğ "`^zzË/;qjĴÇ tŝŭ÷ßéÊ+bzĝáÔŞU+ñŝéÓ§éÜısdccC;w&kkk
Jo= z4½ÄßßRSS)''§Ĝ{ŭúġCúSĵN @GòòòDpLÉÉÉ OuêÔĦ7ng.-N4I,çääDnnndiiDCÀ 0 ´{÷nyĞKR
ħ0 >näŜĞÜÉÁÏÖÖVĵǽY EkŻ^½hàÀâÛ" LiiiSŞÄeh¸ 2%%
²³³Ċġò÷üüü¨K.b{ħĥnŬ,,,ÄtçÖ ²iaC}ÇôE˘QAÀ µK÷!î˘dÉÁ2ĝH0½ĝêH0*¨ µËÛ9·İI³&´2n ÏH |¸dÉÁruâjK@À (,> $Q²L ¸V*YJm àüù,rtôÏ·ëĠìĉ}hâé§?×Gĵ4f\Ċ£Óı[(÷znİġ_Hı >Óע/Mè8RbSÄëŜöŜó[ĉçñĞşÚfĞ&VÔm@7ŜbÒ#`Îl
ÜJMmÒ= ÄÁÛê+µ~îĝÔcPµsÁ°3 ék§ÓÊV×_xùJON§ b ?ŬXê³ÁÁ4yùd:òù
ĝÑŞÉĞÄëo{ <.ĤO~wş¸uQkh{{Ó$#` TdİĜ ¨XúIL Ŝ½İY
rĉDÏ^TiŞ~îìħ³Ôĥ{[µmK'×N˘ĊğÎv´)uÓÓRÜä8ÔQ|Öu´+ Ġ4+3àVösĴN½:â 4г-ĵç,Ozòĝ(Y-·6Ŝ ċÏÔµĴ+Żd)[ĉ½LTeò{ğĥĤOBċïġÙ]ó-ıxşÈ şÒ@ÛÛÌ벨caû+Şd@Ğ%Íb%'ÙÁ6fGNŜLĥĥ*KĠÏqèÌ÷gÔĥ- tŭÒÓD°~ÑZtĵaĵĴÔĤw4ü¨&%K:G zwí}§cNSó6Íċï9
wUĴŬvW9=UMmosj|Şĵ$& µûżÚO 4|Ĉpş{WÚÚTéH£Ê:§F+& iÉşİ5íŻó²-Ûµ=V[ujôr (*4²³²iàĝ˘t'ákZıMħc;µ§ĥ·;üpÇ L 5â6´1cäó__üZë??yµñ˘Ü¤Ĉ˙l\u*Fıí;ÂôÇ?èûWháŜ
ef;¸tÉöíòin_|µŭĞò6ĊêĤAuĥYñ³ŬfNç ˘ żĠ~Fıż˘J ôRڵ޽nßó òĦu³Öéġĥ. µĤĴ˘4ĉ6sç_| ´ %L
)QËz;>okĝċpĤĥĥÙżQï(a ` ` ` ` ` \V U²mÁ6$Ô~ ÒBáFĊ û!& è%//7Ù_;ÊÊÊBbeá³ŭ ô>hz!@âuòèô P¸´Qjj*§§SNNċçç#Q@¨S§ÙĜĜ½½=988ııqdı[·RVVŝÁ -ZĤ!ÉożŬGááôß˙FQA$Żví:äîîN hàÁ"f°qÂT4sÀ1Q@Sz"Ï9
³>ĊóR|ŭ -^ $áĉ-;;\ù[)N#C½ÌK˙F-ş|^RR
Èş´Zĉ_.ÒîŬÉÉÉ~úé, Òż˙Dçtî\İó^x>ûì_Ô°as³Ù2´ éPBê<cZ]Á'-m+uèöìÙì˘<ŝ¸&NüqskAYYbêbüxÚ´iÒ[·n8Ìġë×kV PŻ^ÔİÓ@ş˙ mŜĵúj& ;ßĉeKM}Ĵ{NiòäĠÔ¤I[³Ĝ2´iż $k Ŝuáİ$Zäá° ¨´â7Ès}üŭSfĉ~3Ĥ<żyó*ĊÄÑìÙè Riè×KlqĞÏ?ĝÀ]*!C^#?ż7{zPZÎüĜ×·]¸)ÇċĉŜ -[Ò²ehùòċı
ËċhQè3ê9[+¨vÇvxùòej2jÔ(
´Ŝğd ß+βR%'ŞZġiĊĤÓÎf³M_ )6ĥsëÖġRíÑ]˙üóħħ#ÜÄ>UJ³É˘¸ı½MĦĦëiĉÌÁF?Ëk ³ {yUV kúñÇCĊlÙÚ4>+Ş6 ˘aŬużŭöÛSıŞ&ôïÛ%ċĞUĞNZuĦC
óós%ĥzġ1yÎë6ò"0JN^'ÓlÁ ggR*µ³",î!´kç£û¤Ĵ£:m"ÄôĊÓiĜ°iäâò²rßwÊı>úhħ|ïêĠË ŭ}ĦÏp İßÒ×5kş8qĉÍGÁÁÁ´jĠ*ĥ
6xë-CĝùùĞĞkÇŭQ çé}_ìNRĝ¸p[^ŜMŬ =FÒĥm ÷KôĈ-éĠWŬéß˙{ÍOÄvŝTıOĞKŭ΢vÍf `jܸ
ÍñÒsÏ×K³ICp8ö×_˙kô³Äı6oî)ÎéóÏdzekhÓ úĴ¨Ú´kİÛN9{ö{Mŝè òiÛÖG ·oßöí+$ÊlİD¸uÏû,~ÎĦ"ş1¸ġÚħcIâ°ÒäÉ]ßp|~ş
&N\.Ûµë#ßV0êwŭÖáŬMĜY 9r.]şDġë>`iZ 7z\FĈ9½ïKRûÒàqÜc² zċ ċíÛıJŻú ċ\^:VÈ6-ğtñ%K:Ì˘v}`M#6Ş:Kc6i<\[ògy°ôôŬt˙ŝ]qĈùĴĦMsè³˘jÓ &·ĠÖ°µ{)))JËĥĉ~pÎ`"%e=}öÙòÚÓO××U2úÁ îR{ÛtÁ7Ĉ£GŞĦlcvúá'§§
¨F{ùñż¸(âĥRv nŬş)úTLĠħ÷ Ç=̽{÷Rôó6p\rÜqYÔĴYGz6jr˙ŝ ´re0-\"Żŭŝûo:{eıwÏ´yĞú6ȽµòĜ¤ħĈNI =zâücèÌ£´}ûRò÷](YÈZÚ4>+˘6í>$kjEaN8 ĉ÷4÷ 9DM´£ùó˙ ³MÒ .ÂÙıÜ ÈíÛy%V ċı_ JLĵIô*ÁkòÄÔµkWIöY²d -Z´:uêd4*£ö"Ëz ?gYğĥ³Ŝqu×ŭ +[°ŜŜĠç'+r Ï3gD!ğQ ;T ç,Ğ=VŻ^Sg×Ob<~ÇÙ²Ĉ>[ĞÖsäë;EÊ}ôh2Í7ZZµGmBĊAÒ6mjñĜğ7NĉêÙ Ú) /Ż! żRĈâD(¸ÂàJIîî e*O×Ce
AAÏ~'MdZV`*ĠèîŬ|MÚßùó:;dÇĥiÓ&5kro&IóĜħc×`ße\-?˙ĜÖ]˙$OÏ~ş÷9üÈá°açÎeĥGoÚ³gÁqâOyl{%;}úF£ 7²wqİ' ;úĥloÚ,Ż>µĴML+)ÁaÖ¨á,Bâ1L-aádd¤éĈ~T¸ġÎIEC?*ĵQ ËJ{ÇTxĝsk}ĈÍPüŭ#2äÏż(\eÒçĈ+çúFSĥÇL>!ó/ġ³a{÷îôşĵ%úá#µ oLŭÍ7iûöeɽÈñ£
ŭŝkdL`ĝyYí1 `˘
JïĴ
n0Ù&ġCEçaöY Ğ42%&22AÏ{+uÍEğÒfyġİUm2Ĥĉŝrì&,,ldħLq:iâĈ <ĥlÙLAAhÀÑĝnİ&%ĊÜığp3,@|ürZ²äoÍ
[·ZġÜ ċD c:ç,'qeÍ
@Ö$66\²uMµSS3Ċ ˘YôÉĞ~ŭ>ŞËñ=¸ví´^y'iËġ×÷ĥ˙ŝ¸ Ú´3à0Kà½÷Ŝt~ËrÖ··_
½EÇUe8p`ee¤şuëŭ mÚHú)İ%Qı²$Z0˙ĝG-`)x5kBäqhhhħ5d pv
Oiá4~ :ġ] y `n8Ħ%<Ü.]ÊĤöíÛÓ ~ ĤC...2Ċdúô~pÀìÎrĉÌ~~j×MÑÑÑ&- ´;x /xíìì,)ì&x"< Ìa=ißDqlgîîî¸1 Àa:.[·ĤÔÔT]OsôèfTt' L
|ĈoIÇ ċŝŭûu[y ìÄ~Êà4 =*Û,ñĵL×ĤMó¨""î
zIDAT$KGÖêÀ|pdbßm2u³a ³ä0,z Àaj
ÏrOsíÚµ2Á§ĴX1Iŝ^½İ,FÍ[3ñúÀ**ŬÁa É §¸¸8JLLT*Äò,Gfĉ>.?Oá%í|}}eİ; wÌc]8MèìÓŜğĉJŻ/ż PFF<ÉkÏĉ;wpLäÑ£G²}Û+WèâĊòxàÀäĉV°6/4Î{CrìwŜqdGs\f^×ĠÂüÊ-żÜí ôĦ=}ßYŜ1¸ġ Ĥ8O ä?`,tŜĥ×]+ô^÷îŬm²(ÓÄï}Ĝ4ÛÔġ0M`InŜĵ)â?|ĝ°$ĥp9sĉ íŜ½[ĵ8g6iÒDöäÖ2 ôaw#Ü`nXèĵ1W ĵĵĊ ¸Véê @ &| Ï Ġ3<ĈòîğïʸÒBfÑóbâú;pëĝ ô}ÀaÍÂᣤ¤$:x ÌIċDĞWŻÊn
ĞkĦvìĜQ²B 5 èÀarH7oÖ
T¸ġĴĥeËáfèúÚ
Íc,Ç,,îFÉ{ÇSf8Ä+ÔôêĠKŝóX ô J$33µ(
gIOO9¤<ß+??_÷Ŝ ÈC s^ĈİjĠŞòĝ Ŭ9úÔèú°>0ÓĦàì6OOOÍ_'ï ÁÀ68ŞÓ>uôa]§ Yxö=ûêżñFKj×n 0 êrsşôĴ£ëo³YÊ kWoÊÍŭî5 üüÂqsÙ+è ûÑö, fòòòĤ[·ŝ'Ûyuë6 7 èTà0ËPôîŬOZÎ\,\Bġê½ ô*ÉĦ2ĝí·kôüóġiÑ˘Tl
ôà0>j·ı2Xşt?* VjWh9 } 8LP3İ-guL z:uޤëfÍÚSJÊúbÇ9jê? OĤlE £ =7Tè5¨Xú8}T0 ?~D*aR ĤÔµ"MYĦ+oo?éöí<ò÷6n<_Ïwî\Iŝ§Ĥ>ĥÊ=<}ú;Z´h ŭç?'éµ×RhèzjàM³ÇÚ×X wíJ OŞ
-èàI5dL?híÚ 8LÈżdìe
7~ĦéÓߧDßcM§2oŜ(úä/ÉŬŭ ċĵ[hĊÉ4~ÙÏפ:MPñôa.m8ş,ÍùóÇa
ÌÊ÷(-m+ŭŭï.NcÇĥĤnŬŞÒ1(=}·î=˙ĉı_^gnŜĵJ11a4{ö0úáT:´`â÷§öĦ?^AÏ=WŻĜ9ù\,D>·ËljyĜĜSRI0:
TŜßcĥ2íèÜı òġm@^^Ċĉ~üñA[cèç÷&áF'O Ô}ŜÚ°DùlC×ÄşŭêĞY4cĈûtĉÌÑB!sC×Ğ6HĠ˙Yżèa 2éÄb|M(((J÷ŜÂ
ÊóEôÖ[ EHÜâ\·.KŜËÏÏ%'''Z½ş` Nxċ7Exaĵ}ÖE^3g'Ġİó"]ż~Ĝıù\lÔQQèċQÛĥ½¨aĉ)³İċ52ÓC·Ì@{ú$aÊĉÍ=%|ùùçc%ôWÔÖ¸a6hP05nÜF*zUCĉ%Ëg+ vMħħaÔĴ§âÜC)%eĠŭBİ×ĞFqÔUEÖ/zf`Á@zĉ4eJ´Ò:RHkÖ|/iÚôŻtùòYŬ{99Ù"0u0}ß8êÓçCyŜĦC]+àsġìéOÁÁĞeâ8ĊRe6µĵEIHXEs¸Ì@{úxûíÁà?îİdEmíàÁêÑc¤ê;#shċ³JğĤ½{¨K_){Ç
u[Òġ£ÎA!!ÑJOì[éqkÎ[ÜşuvïŜ@ > §ŞL-Zt*ôY~M
\ı`óÙgqĤû÷ï=7'pKÏÏ=.%Ë\ÖòŝôÓ9ÊͽAmÚô|â2íécôèYôġ×1ÒÚ})ùûÏÖġVôm{túÏMÁT;³FùĴÒ)/ïÎÑWĞV½nKğ^è=L³ÀĊ=-nq½ĝbZµjî=gÖ¨ñ,ĠŻïĤ´êĦ³s Ŭ¸ o2zn>WġêµhòäU4lĜ4C#ĉ(³ħòrBĈĥmEtĉ(3>jĠzNz@CN}Ç+ĥ7ÚàwTŻ^³ÌcfĤÚËg ğ&n Ò)×[ġ iÎîşÒÛâ}ŭ,8 GhÙ²´ K.5ÜËkĊÇŻÔ
xÜÜŜ6zN>SíéY³Ì"/˘qky?ivô1n\ħîñ¸¸ÔC°-îÙ³Ez7Xc
eµ3KÏÖ:0tM;ûJÎŞÛFZ½Ŝ*UŞÑŬğù^żÉZ8JL\#c ½zH$F £ ;ÓĴYCdàöí\ğ.siċ Nżŝú_çT)ë´ŭD˘sĊL;ìSTÔX:>Sİ _Vì&Áàqs($¤RIWĦ
S>{Ôë6!a%
'I¨ĜĜġ3ĤMóQŜûĤBÛĞİĜÂż°°° îgäNS§!eĞyf
Csçî2Ë÷YÚÁğĵötmÖ&66\2Á-ZÛîé<<]Ù! Ĥ
ñóó˙ÙÙÙ¸ÀfÎRµCûÓ÷ úÈÁlĉ,U;´#§ (ÙiP@Ò Àa p & hL+ ""âKÜ ;ĥL/âêzNhÍ·"z +ĝ -:Ks.² (ĉ4 ĊAÒ Àa p & h2M+Ádf Z˘,~ÍT
§ ˙Ü;(+ Ĵ IENDB` commons-cli-1.3.1-src/src/site/resources/images/svg/commandlines.svg 0100644 0000765 0000024 00000004561 12537250704 026174 0 ustar 00bene staff 0000000 0000000
commons-cli-1.3.1-src/src/site/resources/images/svg/diagrams-cli2.js 0100644 0000765 0000024 00000025236 12537250704 025760 0 ustar 00bene staff 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var Option = new Interface("Option");
Option.addMethod("process(...)");
Option.addMethod("canProcess(...)");
Option.addMethod("getTriggers()");
Option.addMethod("getPrefixes()");
Option.addMethod("validate(...)");
Option.addMethod("helpLines(...)");
Option.addMethod("appendUsage(...)");
Option.addMethod("getPreferredName()");
Option.addMethod("getDescription()");
Option.addMethod("getId()");
Option.addMethod("findOption(...)");
var Group = new Interface("Group");
Group.addMethod("appendUsage(...)");
Group.addNote("-a | -b | -c | -d | -e");
var Parent = new Interface("Parent");
Parent.addMethod("processParent(...)");
Parent.addNote("-f ");
var Argument = new Interface("Argument");
Argument.addMethod("getInitialSeparator()");
Argument.addMethod("processValues(...)");
Argument.addMethod("validate(...)");
Argument.addNote(" [ ...]");
var CommandLine = new Interface("CommandLine");
CommandLine.addMethod("hasOption(...)");
CommandLine.addMethod("getOption(...)");
CommandLine.addMethod("getValue(...)");
CommandLine.addMethod("getValues(...)");
CommandLine.addMethod("getSwitch(...)");
CommandLine.addMethod("getProperty(...)");
CommandLine.addMethod("getProperties()");
CommandLine.addMethod("getOptionCount(...)");
CommandLine.addMethod("getOptions()");
CommandLine.addMethod("getOptionTriggers()");
var WriteableCommandLine = new Interface("WriteableCommandLine");
WriteableCommandLine.addMethod("addOption(...)");
WriteableCommandLine.addMethod("addValue(...)");
WriteableCommandLine.addMethod("addSwitch(...)");
WriteableCommandLine.addMethod("addProperty(...)");
WriteableCommandLine.addMethod("looksLikeOption(...)");
var PropertyOption = new Class("PropertyOption");
PropertyOption.addAttribute("optionString");
PropertyOption.addAttribute("description");
PropertyOption.addAttribute("prefixes");
PropertyOption.addNote("-Dproperty=value");
var DefaultOption = new Class("DefaultOption");
DefaultOption.addAttribute("optionString");
DefaultOption.addAttribute("description");
DefaultOption.addAttribute("prefixes");
DefaultOption.addNote("-f (--file, --filelist)");
var Command = new Class("Command");
Command.addAttribute("preferredName");
Command.addAttribute("aliases");
Command.addAttribute("required");
Command.addAttribute("triggers");
Command.addNote("update (up, upd)");
var Switch = new Class("Switch");
Switch.addAttribute("enabledPrefix");
Switch.addAttribute("disabledPrefix");
Switch.addAttribute("preferredName");
Switch.addAttribute("aliases");
Switch.addAttribute("required");
Switch.addAttribute("triggers");
Switch.addAttribute("prefixes");
Switch.addNote("+d|-d (+display|-display)");
var SourceDestArgument = new Class("SourceDestArgument");
SourceDestArgument.addAttribute("preferredName");
SourceDestArgument.addAttribute("aliases");
SourceDestArgument.addAttribute("required");
SourceDestArgument.addAttribute("triggers");
SourceDestArgument.addNote(" ... ");
var Parser = new Class("Parser");
Parser.addMethod("parse(...)");
Parser.addMethod("parseAndHelp(...)");
Parser.addMethod("setGroup(...)");
Parser.addMethod("setHelpFormatter(...)");
Parser.addMethod("setHelpOption(...)");
Parser.addMethod("setHelpTrigger(...)");
var DefaultingCommandLine = new Class("DefaultingCommandLine");
DefaultingCommandLine.addMethod("appendCommandLine(...)");
DefaultingCommandLine.addMethod("insertCommandLine(...)");
DefaultingCommandLine.addMethod("commandLines()");
var PropertiesCommandLine = new Class("PropertiesCommandLine");
PropertiesCommandLine.addAttribute("properties");
PropertiesCommandLine.addNote("java.util.Properties");
var PreferencesCommandLine = new Class("PreferencesCommandLine");
PreferencesCommandLine.addAttribute("preferences");
PreferencesCommandLine.addNote("java.util.prefs.Preferences");
var ArgumentBuilder = new Class("ArgumentBuilder");
ArgumentBuilder.addMethod("withId(...)");
ArgumentBuilder.addMethod("withName(...)");
ArgumentBuilder.addMethod("withDescription(...)");
ArgumentBuilder.addMethod("withConsumeRemaining(...)");
ArgumentBuilder.addMethod("withValidator(...)");
ArgumentBuilder.addMethod("withMinimum(...)");
ArgumentBuilder.addMethod("withMaximum(...)");
ArgumentBuilder.addMethod("withDefault(...)");
ArgumentBuilder.addMethod("withDefaults(...)");
ArgumentBuilder.addMethod("withInitialSeparator(...)");
ArgumentBuilder.addMethod("withSubsequentSeparator(...)");
ArgumentBuilder.addMethod("create()");
ArgumentBuilder.addMethod("reset()");
var CommandBuilder = new Class("CommandBuilder");
CommandBuilder.addMethod("withId(...)");
CommandBuilder.addMethod("withName(...)");
CommandBuilder.addMethod("withDescription(...)");
CommandBuilder.addMethod("withArgument(...)");
CommandBuilder.addMethod("withChildren(...)");
CommandBuilder.addMethod("withRequired(...)");
CommandBuilder.addMethod("create()");
CommandBuilder.addMethod("reset()");
var DefaultOptionBuilder = new Class("DefaultOptionBuilder");
DefaultOptionBuilder.addMethod("withId(...)");
DefaultOptionBuilder.addMethod("withShortName(...)");
DefaultOptionBuilder.addMethod("withLongName(...)");
DefaultOptionBuilder.addMethod("withDescription(...)");
DefaultOptionBuilder.addMethod("withArgument(...)");
DefaultOptionBuilder.addMethod("withChildren(...)");
DefaultOptionBuilder.addMethod("withRequired(...)");
DefaultOptionBuilder.addMethod("create()");
DefaultOptionBuilder.addMethod("reset()");
DefaultOptionBuilder.addAttribute("shortPrefix");
DefaultOptionBuilder.addAttribute("longPrefix");
DefaultOptionBuilder.addAttribute("burstEnabled");
var DefaultOptionBuilder = new Class("DefaultOptionBuilder");
DefaultOptionBuilder.addMethod("withId(...)");
DefaultOptionBuilder.addMethod("withShortName(...)");
DefaultOptionBuilder.addMethod("withLongName(...)");
DefaultOptionBuilder.addMethod("withDescription(...)");
DefaultOptionBuilder.addMethod("withArgument(...)");
DefaultOptionBuilder.addMethod("withChildren(...)");
DefaultOptionBuilder.addMethod("withRequired(...)");
DefaultOptionBuilder.addMethod("create()");
DefaultOptionBuilder.addMethod("reset()");
var GroupBuilder = new Class("GroupBuilder");
GroupBuilder.addMethod("withName(...)");
GroupBuilder.addMethod("withDescription(...)");
GroupBuilder.addMethod("withOption(...)");
GroupBuilder.addMethod("withMinimum(...)");
GroupBuilder.addMethod("withMaximum(...)");
GroupBuilder.addMethod("create()");
GroupBuilder.addMethod("reset()");
var PatternBuilder = new Class("PatternBuilder");
PatternBuilder.addMethod("withPattern(...)");
PatternBuilder.addMethod("create()");
PatternBuilder.addMethod("reset()");
PatternBuilder.addAttribute("groupBuilder");
PatternBuilder.addAttribute("optionBuilder");
PatternBuilder.addAttribute("argumentBuilder");
var SwitchBuilder = new Class("SwitchBuilder");
SwitchBuilder.addMethod("withId(...)");
SwitchBuilder.addMethod("withName(...)");
SwitchBuilder.addMethod("withDescription(...)");
SwitchBuilder.addMethod("withArgument(...)");
SwitchBuilder.addMethod("withChildren(...)");
SwitchBuilder.addMethod("withRequired(...)");
SwitchBuilder.addMethod("create()");
SwitchBuilder.addMethod("reset()");
SwitchBuilder.addAttribute("enabledPrefix");
SwitchBuilder.addAttribute("disabledPrefix");
var Validator = new Class("Validator");
Validator.addMethod("validate(...)");
var ClassValidator = new Class("ClassValidator");
ClassValidator.addAttribute("classLoader");
ClassValidator.addAttribute("instance");
ClassValidator.addAttribute("loadable");
var DateValidator = new Class("DateValidator");
DateValidator.addAttribute("formats");
DateValidator.addAttribute("minimum");
DateValidator.addAttribute("maximum");
var EnumValidator = new Class("EnumValidator");
EnumValidator.addAttribute("validValues");
var FileValidator = new Class("FileValidator");
FileValidator.addAttribute("directory");
FileValidator.addAttribute("existing");
FileValidator.addAttribute("file");
FileValidator.addAttribute("hidden");
FileValidator.addAttribute("readable");
FileValidator.addAttribute("writable");
var FileValidator = new Class("FileValidator");
FileValidator.addAttribute("format");
FileValidator.addAttribute("minimum");
FileValidator.addAttribute("maximum");
var UrlValidator = new Class("UrlValidator");
UrlValidator.addAttribute("format");
UrlValidator.addAttribute("minimum");
UrlValidator.addAttribute("maximum");
var Comparators = new Class("Comparators");
Comparators.addMethod("chain(...)");
Comparators.addMethod("commandFirst(...)");
Comparators.addMethod("commandLast(...)");
Comparators.addMethod("defaultOptionFirst(...)");
Comparators.addMethod("defaultOptionLast(...)");
Comparators.addMethod("groupFirst(...)");
Comparators.addMethod("groupLast(...)");
Comparators.addMethod("namedFirst(...)");
Comparators.addMethod("namedLast(...)");
Comparators.addMethod("preferredNameFirst(...)");
Comparators.addMethod("preferredNameLast(...)");
Comparators.addMethod("requiredFirst(...)");
Comparators.addMethod("requiredLast(...)");
Comparators.addMethod("switchFirst(...)");
Comparators.addMethod("switchLast(...)");
var HelpFormatter = new Class("HelpFormatter");
HelpFormatter.addMethod("print()");
HelpFormatter.addMethod("printDivider()");
HelpFormatter.addMethod("printException()");
HelpFormatter.addMethod("printFooter()");
HelpFormatter.addMethod("printGutterLeft()");
HelpFormatter.addMethod("printGutterRight()");
HelpFormatter.addMethod("printHeader()");
HelpFormatter.addMethod("printHelp()");
HelpFormatter.addMethod("printUsage()");
HelpFormatter.addAttribute("comparator");
HelpFormatter.addAttribute("displaySettings");
HelpFormatter.addAttribute("divider");
HelpFormatter.addAttribute("exception");
HelpFormatter.addAttribute("footer");
HelpFormatter.addAttribute("fullUsageSettings");
HelpFormatter.addAttribute("group");
HelpFormatter.addAttribute("gutterCenter");
HelpFormatter.addAttribute("gutterLeft");
HelpFormatter.addAttribute("gutterRight");
HelpFormatter.addAttribute("header");
HelpFormatter.addAttribute("lineUsageSettings");
HelpFormatter.addAttribute("pageWidth");
HelpFormatter.addAttribute("printWriter");
HelpFormatter.addAttribute("shellCommand");
commons-cli-1.3.1-src/src/site/resources/images/svg/diagrams.css 0100644 0000765 0000024 00000003076 12537250704 025303 0 ustar 00bene staff 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
.option .outline, .option polygon.note {
fill:rgb(191,255,255);
}
.group rect.outline, .group polygon.note {
fill:rgb(255,191,191);
}
.parent rect.outline, .parent polygon.note {
fill:rgb(191,255,191);
}
.argument rect.outline, .argument polygon.note {
fill:rgb(191,191,255);
}
.property rect.outline, .property polygon.note {
fill:rgb(255,191,255);
}
.package rect {
fill:rgb(255,255,191);
}
.package rect.inner {
fill: rgb(255,255,255);
stroke: none;
}
text.title {
text-anchor: middle;
}
.type text {
fill: rgb(0,0,0);
}
rect, line, polygon, polyline {
stroke:rgb(0,0,0);
stroke-width:2;
stroke-linejoin: bevel;
stroke-linecap: round;
}
.implements, .extends {
fill: none;
marker-end: url(util.svg#HollowArrow);
}
.implements, .note.connect {
stroke-dasharray: 5;
}
commons-cli-1.3.1-src/src/site/resources/images/svg/diagrams.js 0100644 0000765 0000024 00000021526 12537250704 025127 0 ustar 00bene staff 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var textHeight = 10;
var padding = 10;
var namespace = "http://www.w3.org/2000/svg";
var displayAttributes = true;
var displayMethods = true;
var displayNotes = true;
function Type(name){
this.width = 160;
this.style = "type";
this.insert = function(evt){
y = 0;
y = this.insertOutline(evt,y);
y = this.insertName(evt,y);
if(displayAttributes==true){
y = this.insertAttributes(evt,y);
}
if(displayMethods==true){
y = this.insertMethods(evt,y);
}
if(displayNotes==true){
y = this.insertNotes(evt,y);
}
}
this.height = function(){
height = 0;
height += this.heightName();
if(displayAttributes==true){
height += this.heightAttributes();
}
if(displayMethods==true){
height += this.heightMethods();
}
return height;
}
this.insertOutline = function(evt,y){
style = evt.target.getAttributeNS(null, "class");
evt.target.setAttributeNS(null,"class",style+" "+this.style);
e = document.createElementNS(namespace, "rect");
e.setAttributeNS(null, "x", 0);
e.setAttributeNS(null, "y", 0);
e.setAttributeNS(null, "width", this.width);
e.setAttributeNS(null, "height", this.height());
e.setAttributeNS(null, "class", "outline");
evt.target.appendChild(e);
return y;
}
this.name = name;
this.heightName = function(){
return padding * 2 + textHeight;
}
this.insertName = function(evt,y){
y += padding;
y += textHeight;
e = document.createElementNS(namespace, "text");
e.setAttributeNS(null, "x", this.width/2);
e.setAttributeNS(null, "y", y);
e.setAttributeNS(null, "class", "title");
e.appendChild(document.createTextNode(this.name));
evt.target.appendChild(e);
y += padding;
return y;
}
this.attributeList = new Array();
this.attributeCount = 0;
this.addAttribute = function(text){
this.attributeList[this.attributeCount++]=text;
}
this.heightAttributes = function(){
if(this.attributeCount>0){
return padding * 2 + this.attributeCount*textHeight;
}
else{
return padding;
}
}
this.insertAttributes = function(evt,y){
e = document.createElementNS(namespace, "line");
e.setAttributeNS(null, "x1", 0);
e.setAttributeNS(null, "y1", y);
e.setAttributeNS(null, "x2", this.width);
e.setAttributeNS(null, "y2", y);
e.setAttributeNS(null, "class", "divider");
evt.target.appendChild(e);
y += padding;
for(i=0;i0){
y += padding;
}
return y;
}
this.methodList = new Array();
this.methodCount = 0;
this.addMethod = function(text){
this.methodList[this.methodCount++]=text;
}
this.heightMethods = function(){
if(this.methodCount>0){
return padding * 2 + this.methodCount*textHeight;
}
else{
return padding;
}
}
this.insertMethods = function(evt,y){
e = document.createElementNS(namespace, "line");
e.setAttributeNS(null, "x1", 0);
e.setAttributeNS(null, "y1", y);
e.setAttributeNS(null, "x2", this.width);
e.setAttributeNS(null, "y2", y);
e.setAttributeNS(null, "class", "divider");
evt.target.appendChild(e);
y += padding;
for(i=0;i0){
y += padding;
}
return y;
}
this.noteList = new Array();
this.noteCount = 0;
this.addNote = function(text){
this.noteList[this.noteCount++]=text;
}
this.insertNotes = function(evt,y){
if(this.noteCount>0){
joinTop = y;
y += padding;
e = document.createElementNS(namespace, "line");
e.setAttributeNS(null, "x1", this.width/2-padding*2);
e.setAttributeNS(null, "y1", y);
e.setAttributeNS(null, "x2", this.width/2+padding*2);
e.setAttributeNS(null, "y2", joinTop);
e.setAttributeNS(null, "class", "note connect");
evt.target.appendChild(e);
height = this.heightNotes();
e = document.createElementNS(namespace, "polygon");
e.setAttributeNS(null, "points", "0,"+(y+padding)+" 0,"+(y+height)+" "+this.width+","+(y+height)+" "+this.width+","+y+" "+padding+","+y);
e.setAttributeNS(null, "class", "note");
evt.target.appendChild(e);
e = document.createElementNS(namespace, "polygon");
e.setAttributeNS(null, "points", ""+padding+","+y+" 0,"+(y+padding)+" "+padding+","+(y+padding));
e.setAttributeNS(null, "class", "note corner");
evt.target.appendChild(e);
y += padding;
for(i=0;i0){
return padding*2 + this.noteCount*textHeight;
}
}
}
function Interface(name){
this.superclass = Type;
this.superclass(name);
delete this.superclass;
this.rounded = true;
this.insertOutline = function(evt,y){
style = evt.target.getAttributeNS(null, "class");
evt.target.setAttributeNS(null,"class",style+" "+this.style);
e = document.createElementNS(namespace, "rect");
e.setAttributeNS(null, "x", 0);
e.setAttributeNS(null, "y", 0);
e.setAttributeNS(null, "width", this.width);
e.setAttributeNS(null, "height", this.height());
e.setAttributeNS(null, "rx", padding*1.5);
e.setAttributeNS(null, "ry", padding*1.5);
e.setAttributeNS(null, "class", "outline");
evt.target.appendChild(e);
return y;
}
this.heightAttributes = function(){
return 0;
}
this.insertAttributes = function(evt,y){
return y;
}
}
Interface.prototype = new Type;
function Class(name){
this.superclass = Type;
this.superclass(name);
delete this.superclass;
this.rounded = false;
}
Class.prototype = new Type;
function PackageSymbol(name,width,height){
this.name = name;
this.nameWidth = 150;
this.width = width;
this.height = height;
this.insert = function(evt){
style = evt.target.getAttributeNS(null, "class");
evt.target.setAttributeNS(null,"class",style+" package");
first = evt.target.getFirstChild();
e = document.createElementNS(namespace, "rect");
e.setAttributeNS(null, "x", 0);
e.setAttributeNS(null, "y", 0);
e.setAttributeNS(null, "width", this.nameWidth);
e.setAttributeNS(null, "height", textHeight+padding);
e.setAttributeNS(null, "class", "outline");
e.appendChild(document.createTextNode(this.name));
evt.target.insertBefore(e,first);
e = document.createElementNS(namespace, "text");
e.setAttributeNS(null, "x", this.nameWidth/2);
e.setAttributeNS(null, "y", textHeight+padding/2);
e.setAttributeNS(null, "class", "title");
e.appendChild(document.createTextNode(this.name));
evt.target.insertBefore(e,first);
e = document.createElementNS(namespace, "rect");
e.setAttributeNS(null, "x", 0);
e.setAttributeNS(null, "y", textHeight+padding);
e.setAttributeNS(null, "width", this.width);
e.setAttributeNS(null, "height", this.height-textHeight-padding);
e.setAttributeNS(null, "class", "outline");
e.appendChild(document.createTextNode(this.name));
evt.target.insertBefore(e,first);
e = document.createElementNS(namespace, "rect");
e.setAttributeNS(null, "x", padding);
e.setAttributeNS(null, "y", textHeight+padding*2);
e.setAttributeNS(null, "width", this.width-padding*2);
e.setAttributeNS(null, "height", this.height-textHeight-padding*3);
e.setAttributeNS(null, "class", "inner");
e.appendChild(document.createTextNode(this.name));
evt.target.insertBefore(e,first);
}
}
commons-cli-1.3.1-src/src/site/resources/images/svg/options.svg 0100644 0000765 0000024 00000005453 12537250704 025217 0 ustar 00bene staff 0000000 0000000
commons-cli-1.3.1-src/src/site/resources/images/svg/util.svg 0100644 0000765 0000024 00000003314 12537250704 024473 0 ustar 00bene staff 0000000 0000000
commons-cli-1.3.1-src/src/site/resources/profile.jacoco 0100644 0000765 0000024 00000000000 12537250704 023536 0 ustar 00bene staff 0000000 0000000 commons-cli-1.3.1-src/src/site/site.xml 0100644 0000765 0000024 00000003715 12537250704 020412 0 ustar 00bene staff 0000000 0000000
Commons CLI
/images/logo.png
/index.html
commons-cli-1.3.1-src/src/site/xdoc/download_cli.xml 0100644 0000765 0000024 00000015307 12537250704 023041 0 ustar 00bene staff 0000000 0000000
Download Apache Commons CLI
Commons Documentation Team
We recommend you use a mirror to download our release
builds, but you must verify the integrity of
the downloaded files using signatures downloaded from our main
distribution directories. Recent releases (48 hours) may not yet
be available from the mirrors.
You are currently using [preferred] . If you
encounter a problem with this mirror, please select another
mirror. If all mirrors are failing, there are backup
mirrors (at the end of the mirrors list) that should be
available.
The KEYS
link links to the code signing keys used to sign the product.
The PGP link downloads the OpenPGP compatible signature from our main site.
The MD5 link downloads the checksum from the main site.
Older releases can be obtained from the archives.
commons-cli-1.3.1-src/src/site/xdoc/index.xml 0100644 0000765 0000024 00000011505 12537250704 021506 0 ustar 00bene staff 0000000 0000000
Home
commons-dev
The Apache Commons CLI library provides an API for parsing command line options passed to programs.
It's also able to print help messages detailing the options available for a command line tool.
Commons CLI supports different types of options:
POSIX like options (ie. tar -zxvf foo.tar.gz)
GNU like long options (ie. du --human-readable --max-depth=1)
Java like properties (ie. java -Djava.awt.headless=true -Djava.net.useSystemProxies=true Foo)
Short options with value attached (ie. gcc -O2 foo.c)
long options with single hyphen (ie. ant -projecthelp)
A typical help message displayed by Commons CLI looks like this:
usage: ls
-A,--almost-all do not list implied . and ..
-a,--all do not hide entries starting with .
-B,--ignore-backups do not list implied entried ending with ~
-b,--escape print octal escapes for nongraphic characters
--block-size <SIZE> use SIZE-byte blocks
-c with -lt: sort by, and show, ctime (time of last
modification of file status information) with
-l:show ctime and sort by name otherwise: sort
by ctime
-C list entries by columns
Check out the introduction page for a detailed presentation.
Commons CLI 1.0 was formed from the merger of ideas and code from three different libraries -
Werken, Avalon and Optz. In dealing with the bugs and the feature requests a freshly designed and not
backwards compatible CLI 2 was created in 2004, but never finished or released.
The current plan is to continue to maintain the 1.x line. The CLI2 work may be found in the Commons Sandbox.
The commons mailing lists act as the main support forum. The user list
is suitable for most library usage queries. The dev list is intended for the development discussion. Please
remember that the lists are shared between all commons components, so prefix your email subject by
[cli].
Issues may be reported via the ASF JIRA .
commons-cli-1.3.1-src/src/site/xdoc/introduction.xml 0100644 0000765 0000024 00000007427 12537250704 023130 0 ustar 00bene staff 0000000 0000000
commons-dev
Introduction
There are three stages to command line processing. They are the
definition, parsing and interrogation stages. The following
sections will discuss each of these stages in turn, and discuss how
to implement them with CLI.
Each command line must define the set of options that will be used
to define the interface to the application.
CLI uses the
Options class, as a container for
Option instances. There are two ways to create
Options in CLI. One of them is via the constructors,
the other way is via the factory methods defined in
Options.
The Usage Scenarios document provides
examples how to create an Options object and also
provides some real world examples.
The result of the definition stage is an Options
instance.
The parsing stage is where the text passed into the
application via the command line is processed. The text is
processed according to the rules defined by the parser
implementation.
The parse method defined on
CommandLineParser takes an Options
instance and a String[] of arguments and
returns a
CommandLine .
The result of the parsing stage is a CommandLine
instance.
The interrogation stage is where the application queries the
CommandLine to decide what execution branch to
take depending on boolean options and uses the option values
to provide the application data.
This stage is implemented in the user code. The accessor methods
on CommandLine provide the interrogation capability
to the user code.
The result of the interrogation stage is that the user code
is fully informed of all the text that was supplied on the command
line and processed according to the parser and Options
rules.
commons-cli-1.3.1-src/src/site/xdoc/issue-tracking.xml 0100644 0000765 0000024 00000013207 12537250704 023330 0 ustar 00bene staff 0000000 0000000
Commons CLI Issue tracking
Commons Documentation Team
Please also remember these points:
the more information you provide, the better we can help you
test cases are vital, particularly for any proposed enhancements
the developers of Commons CLI are all unpaid volunteers
For more information on subversion and creating patches see the
Apache Contributors Guide .
You may also find these links useful:
commons-cli-1.3.1-src/src/site/xdoc/mail-lists.xml 0100644 0000765 0000024 00000022210 12537250704 022450 0 ustar 00bene staff 0000000 0000000
Commons CLI Mailing Lists
Commons Documentation Team
Commons CLI shares mailing lists with all the other
Commons Components .
To make it easier for people to only read messages related to components they are interested in,
the convention in Commons is to prefix the subject line of messages with the component's name,
for example:
[cli] Problem with the ...
Questions related to the usage of Commons CLI should be posted to the
User List .
Developer List
is for questions and discussion related to the development of Commons CLI.
Note: please don't send patches or attachments to any of the mailing lists.
Patches are best handled via the Issue Tracking system.
Otherwise, please upload the file to a public server and include the URL in the mail.
Please prefix the subject line of any messages for Commons CLI
with [cli] - thanks!
Other mailing lists which you may find useful include:
commons-cli-1.3.1-src/src/site/xdoc/properties.xml 0100644 0000765 0000024 00000006750 12537250704 022601 0 ustar 00bene staff 0000000 0000000
commons-dev
Option Properties
The following are the properties that each
Option has. All of these
can be set using the accessors or using the methods
defined in the
OptionBuilder .
Name
Type
Description
opt
java.lang.String
the identification string of the Option.
longOpt
java.lang.String
an alias and more descriptive identification string
description
java.lang.String
a description of the function of the option
required
boolean
a flag to say whether the option must appear on
the command line.
arg
boolean
a flag to say whether the option takes an argument
args
boolean
a flag to say whether the option takes more than one argument
optionalArg
boolean
a flag to say whether the option's argument is optional
argName
java.lang.String
the name of the argument value for the usage statement
valueSeparator
char
the character value used to split the argument string, that
is used in conjunction with multipleArgs e.g.
if the separator is ',' and the argument string is 'a,b,c' then
there are three argument values, 'a', 'b' and 'c'.
type
java.lang.Object
the type of the argument
value
java.lang.String
the value of the option
values
java.lang.String[]
the values of the option
commons-cli-1.3.1-src/src/site/xdoc/release_1_0.xml 0100644 0000765 0000024 00000003006 12537250704 022453 0 ustar 00bene staff 0000000 0000000
Release notes for CLI 1.0
Commons Documentation Team
These are the release notes for Commons CLI 1.0.
INTRODUCTION:
This document contains the release notes for this version of the Commons
CLI package. Commons CLI provides a simple API for working with the
command line arguments and options.
This is the first release of the CLI component, therefore all features are new,
there are no bug-fixes, nothing is deprecated and there are no changes.
For more information, read the documentation on the project site at
http://commons.apache.org/cli/
commons-cli-1.3.1-src/src/site/xdoc/release_1_2.xml 0100644 0000765 0000024 00000006724 12537250704 022467 0 ustar 00bene staff 0000000 0000000
Release notes for CLI 1.2
Commons Documentation Team
These are the release notes for Commons CLI 1.2.
INTRODUCTION:
This document contains the release notes for this version of the Commons CLI
package. Commons CLI provides a simple API for working with the command line
arguments and options.
Commons CLI 1.2 is a bugfix release. The following notable changes were made:
* A major regression introduced in CLI 1.1 that prevented the usage of repeated options has been fixed.
* Several parser issues have been fixed, especially with the PosixParser.
* HelpFormatter now wraps the lines properly
* The ordering of the option in the help message can now be defined.
* Various API enhancements (improved exceptions, serializable classes)
Commons CLI 1.2 is binary compatible with the previous versions, except for
the OptionValidator class that is no longer public.
More information can be found on the project site at http://commons.apache.org/cli
NEW FEATURES:
* The method getOptionProperties() in the CommandLine class was added
to retrieve easily the key/value pairs specified with options like
-Dkey1=value1 -Dkey2=value2.
* GnuParser now supports long options with an '=' sign
(ie. --foo=bar and -foo=bar) (CLI-157)
* The ordering of options can be defined in help messages. (CLI-155)
BUG FIXES:
* The number of arguments defined for an option specifies the arguments
per occurrence of the option and not for all occurrences. (CLI-137)
* PosixParser no longer ignores unrecognized short options. (CLI-164)
* PosixParser no longer stops the bursting process of a token if stopAtNonOption
is enabled and a non option character is encountered. (CLI-163)
* PosixParser no longer keeps processing the tokens after an unrecognized
long option when stopAtNonOption is enabled. (CLI-165)
* Required options are properly checked if an Options instance is used twice
to parse a command line. (CLI-156)
* The line wrapping in HelpFormatter now works properly. (CLI-151)
CHANGES:
* The message of MissingOptionException has been improved. (CLI-149)
* The exceptions have been enhanced with methods to retrieve easily
the related options. (CLI-86)
* Option.toString() now reports arguments properly. (CLI-141)
* The Parser class has been changed to be more easily extendable. (CLI-142)
* The following classes are now serializable: Option, OptionGroup,
CommandLine and Options. (CLI-140)
* OptionValidator is no longer public, its methods were all private.
commons-cli-1.3.1-src/src/site/xdoc/release_1_3.xml 0100644 0000765 0000024 00000014332 12537250704 022462 0 ustar 00bene staff 0000000 0000000
Release notes for CLI 1.3
Commons Documentation Team
These are the release notes for Commons CLI 1.3.
INTRODUCTION:
This document contains the release notes for this version of the Commons CLI
package. Commons CLI provides a simple API for working with the command line
arguments and options.
Commons CLI 1.3 is a bugfix and feature release and binary compatible with the
previous versions, except for the OptionValidator class that is no longer public
(change introduced in v1.2). Commons CLI 1.3 at least requires Java 5.0.
More information can be found on the project site at
http://commons.apache.org/cli.
NOTES
=====
A new parser is available: DefaultParser. It combines the features of the
GnuParser and the PosixParser. It also provides additional features like
partial matching for the long options, and long options without
separator (i.e like the JVM memory settings: -Xmx512m). This new parser
deprecates the previous ones.
DEPRECATIONS
============
o org.apache.commons.cli.BasicParser
replaced by org.apache.commons.cli.DefaultParser
o org.apache.commons.cli.GnuParser
replaced by org.apache.commons.cli.DefaultParser
o org.apache.commons.cli.OptionBuilder
replaced by org.apache.commons.cli.Option.builder()
org.apache.commons.cli.Option.builder(String)
org.apache.commons.cli.Option.Builder
o org.apache.commons.cli.Parser
replaced by org.apache.commons.cli.DefaultParser
o org.apache.commons.cli.PosixParser
replaced by org.apache.commons.cli.DefaultParser
NEW FEATURES
============
o CLI-161: PosixParser doesn't stop the parsing on "--" tokens following an
option with an argument
o CLI-167: Support options like Java memory settings (-Xmx512M)
o CLI-181: Unified Parser
o CLI-224: Added new fluent API to create Option instances via builder class
Option.Builder. This replaces the now deprecated OptionBuilder.
Thanks to Duncan Jones, Brian Blount.
o CLI-160: PosixParser now supports partial long options (--ver instead of
--version).
o CLI-169: HelpFormatter now supports setting the displayed separator of long
options. Thanks to J. Lewis Muir.
o CLI-214: Added new method Options.addOption(String, String). Thanks to
Alexandru Mocanu.
BUG FIXES
=========
o CLI-248: Dead links on doc page.
o CLI-234: Fixed code example in javadoc of
"Option#Builder#valueSeparator(char)". Thanks to Greg Thomas.
o CLI-241: Clarified behavior of "OptionValidator#validateOption(String)"
in case of null input. Thanks to Beluga Behr.
o CLI-202: Default options will now work correctly with required options that
are missing.
o CLI-203: Default options will now work correctly together with option groups.
o CLI-205: HelpFormatter.setArgName(String) now correctly sets the argument
name.
o CLI-204: Passing default values for not defined options to a parser will now
trigger a ParseException instead of a NullPointerException.
o CLI-201: Default properties provided as input to the Parser.parse() methods
are now correctly processed.
o CLI-215: CommandLine.getParsedOptionValue() now returns a String object if no
option type has been explicitly set. Thanks to Manuel Mĵller.
o CLI-212: HelpFormatter now prints command-line options in the same order as
they have been added. Thanks to Per Cederberg.
o CLI-186: Standard help text now shows mandatory arguments also for the first
option. Thanks to Kristoff Kiefer.
o CLI-207: HelpFormatter does not strip anymore leading whitespace in the
footer text. Thanks to Uri Moszkowicz.
o CLI-185: Strip quotes contained in argument values only if there is exactly
one at the beginning and one at the end. Thanks to
Einar M. R. Rosenvinge.
o CLI-184: Negative numerical arguments take precedence over numerical options.
o CLI-193: Fix possible StringIndexOutOfBoundsException in HelpFormatter.
Thanks to Travis McLeskey.
o CLI-183: OptionGroups no longer throw an AlreadySelectedException when reused
for several parsings.
o CLI-182: OptionGroup now selects properly an option with no short name.
CHANGES
=======
o CLI-240: Small cleanup of Option class. Thanks to Beluga Behr.
o CLI-230: Options.getRequiredOptions() now returns an unmodifiable list.
o CLI-218: Clarify javadoc for CommandLine.getOptionValue() that the first
specified argument will be returned. Thanks to Sven.
o CLI-227: Changed unit tests to junit 4 annotation style. Thanks to
Duncan Jones.
o CLI-209: The javadoc of OptionBuilder now states that the class is not
thread-safe. Thanks to Thomas Herre.
o CLI-200: Fixed typo in javadoc of class CommandLine. Thanks to
Gerard Weatherby.
o CLI-223: Source code now uses generic types instead of raw types where
possible. Thanks to Gerard Weatherby.
o CLI-220 Corrected javadoc for return type of
MissingOptionException.getMissingOptions(). Thanks to Joe Casadonte.
o CLI-197: Improve description of parameter "stopAtNonOption" in method
CommandLine.parse(Options, String[], boolean). Thanks to
Anders Larsson.
o CLI-231: Removed DoubleCheckedLocking test from checkstyle configuration.
Thanks to Duncan Jones.
commons-cli-1.3.1-src/src/site/xdoc/release_1_3_1.xml 0100644 0000765 0000024 00000003246 12537250704 022704 0 ustar 00bene staff 0000000 0000000
Release notes for CLI 1.3.1
Commons Documentation Team
These are the release notes for Commons CLI 1.3.1.
INTRODUCTION:
This document contains the release notes for this version of the Commons CLI
package. Commons CLI provides a simple API for working with the command line
arguments and options.
Commons CLI 1.3.1 is a bug fix release and binary compatible with the
previous versions, except for the OptionValidator class that is no longer public
(change introduced in v1.2). Commons CLI 1.3.1 at least requires Java 5.0.
More information can be found on the project site at
http://commons.apache.org/cli.
BUG FIXES
=========
o CLI-252: LongOpt falsely detected as ambiguous. Thanks to Simon Harrer.
commons-cli-1.3.1-src/src/site/xdoc/upgrading-1.0-to-1.1.xml 0100644 0000765 0000024 00000004253 12537250704 023572 0 ustar 00bene staff 0000000 0000000
Upgrading from 1.0 to 1.1
Commons Documentation Team
CLI 1.1 is a bugfix release of CLI. The following changes notable API changes were made:
The Parser abstract class has two additional parse methods that take a Properties parameter.
The HelpFormatter class had publicly accessible fields. These should now be accessed via
get/set methods and the public fields are deprecated.
The Option class addValue(String) method now throws UnsupportedOperationException.
OptionValidator is a newly added class.
Option's now have equals(Object) and hashCode() methods.
The Option class also received two new methods, setDescription(String) and hasValueSeparator();boolean.
The jar should be API backwards compatible, though if you were calling addValue(String) then you won't be happy. Please
let us know your use case if that is so.
commons-cli-1.3.1-src/src/site/xdoc/usage.xml 0100644 0000765 0000024 00000040202 12537250704 021477 0 ustar 00bene staff 0000000 0000000
commons-dev
Usage Scenarios
The following sections describe some example scenarios on how to
use CLI in applications.
A boolean option is represented on a command line by the presence
of the option, i.e. if the option is found then the option value
is true, otherwise the value is false.
The DateApp utility prints the current date to standard
output. If the -t option is present the current time is
also printed.
An
Options object must be created and the Option must be
added to it.
// create Options object
Options options = new Options();
// add t option
options.addOption("t", false, "display current time");
The addOption method has three parameters. The first
parameter is a java.lang.String that represents the option.
The second parameter is a boolean that specifies whether the
option requires an argument or not. In the case of a boolean option
(sometimes referred to as a flag) an argument value is not present so
false is passed. The third parameter is the description
of the option. This description will be used in the usage text of the
application.
The parse methods of CommandLineParser are used
to parse the command line arguments. There may be several implementations
of the CommandLineParser interface, the recommended one is the
DefaultParser.
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.parse( options, args);
Now we need to check if the t option is present. To do
this we will interrogate the
CommandLine
object. The hasOption method takes a
java.lang.String parameter and returns true if the option
represented by the java.lang.String is present, otherwise
it returns false.
if(cmd.hasOption("t")) {
// print the date and time
}
else {
// print the date
}
The InternationalDateApp utility extends the
DateApp utility by providing the ability to print the
date and time in any country in the world. To facilitate this a new
command line option, c, has been introduced.
// add c option
options.addOption("c", true, "country code");
The second parameter is true this time. This specifies that the
c option requires an argument value. If the required option
argument value is specified on the command line it is returned,
otherwise null is returned.
The getOptionValue methods of CommandLine are
used to retrieve the argument values of options.
// get c option value
String countryCode = cmd.getOptionValue("c");
if(countryCode == null) {
// print default date
}
else {
// print date for country specified by countryCode
}
One of the most ubiquitous Java applications
Ant will be used
here to illustrate how to create the Options required. The following
is the help output for Ant.
ant [options] [target [target2 [target3] ...]]
Options:
-help print this message
-projecthelp print project help information
-version print the version information and exit
-quiet be extra quiet
-verbose be extra verbose
-debug print debugging information
-emacs produce logging information without adornments
-logfile <file> use given file for log
-logger <classname> the class which is to perform logging
-listener <classname> add an instance of class as a project listener
-buildfile <file> use given buildfile
-D<property>=<value> use value for given property
-find <file> search for buildfile towards the root of the
filesystem and use it
Lets create the boolean options for the application as they
are the easiest to create. For clarity the constructors for
Option are used here.
Option help = new Option( "help", "print this message" );
Option projecthelp = new Option( "projecthelp", "print project help information" );
Option version = new Option( "version", "print the version information and exit" );
Option quiet = new Option( "quiet", "be extra quiet" );
Option verbose = new Option( "verbose", "be extra verbose" );
Option debug = new Option( "debug", "print debugging information" );
Option emacs = new Option( "emacs",
"produce logging information without adornments" );
The argument options are created using the OptionBuilder.
Option logfile = OptionBuilder.withArgName( "file" )
.hasArg()
.withDescription( "use given file for log" )
.create( "logfile" );
Option logger = OptionBuilder.withArgName( "classname" )
.hasArg()
.withDescription( "the class which it to perform "
+ "logging" )
.create( "logger" );
Option listener = OptionBuilder.withArgName( "classname" )
.hasArg()
.withDescription( "add an instance of class as "
+ "a project listener" )
.create( "listener");
Option buildfile = OptionBuilder.withArgName( "file" )
.hasArg()
.withDescription( "use given buildfile" )
.create( "buildfile");
Option find = OptionBuilder.withArgName( "file" )
.hasArg()
.withDescription( "search for buildfile towards the "
+ "root of the filesystem and use it" )
.create( "find" );
The last option to create is the Java property and it is also created
using the OptionBuilder.
Option property = OptionBuilder.withArgName( "property=value" )
.hasArgs(2)
.withValueSeparator()
.withDescription( "use value for given property" )
.create( "D" );
The map of properties specified by this option can later be retrieved by
calling getOptionProperties("D") on the CommandLine.
Now that we have created each
Option we need
to create the
Options
instance. This is achieved using the
addOption
method of Options.
Options options = new Options();
options.addOption( help );
options.addOption( projecthelp );
options.addOption( version );
options.addOption( quiet );
options.addOption( verbose );
options.addOption( debug );
options.addOption( emacs );
options.addOption( logfile );
options.addOption( logger );
options.addOption( listener );
options.addOption( buildfile );
options.addOption( find );
options.addOption( property );
All the preperation is now complete and we are now ready to
parse the command line arguments.
We now need to create a CommandLineParser. This will parse the command
line arguments, using the rules specified by the Options and
return an instance of CommandLine .
public static void main( String[] args ) {
// create the parser
CommandLineParser parser = new DefaultParser();
try {
// parse the command line arguments
CommandLine line = parser.parse( options, args );
}
catch( ParseException exp ) {
// oops, something went wrong
System.err.println( "Parsing failed. Reason: " + exp.getMessage() );
}
}
To see if an option has been passed the hasOption
method is used. The argument value can be retrieved using
the getOptionValue method.
// has the buildfile argument been passed?
if( line.hasOption( "buildfile" ) ) {
// initialise the member variable
this.buildfile = line.getOptionValue( "buildfile" );
}
CLI also provides the means to automatically generate usage
and help information. This is achieved with the
HelpFormatter
class.
// automatically generate the help statement
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp( "ant", options );
When executed the following output is produced:
usage: ant
-D <property=value> use value for given property
-buildfile <file> use given buildfile
-debug print debugging information
-emacs produce logging information without adornments
-file <file> search for buildfile towards the root of the
filesystem and use it
-help print this message
-listener <classname> add an instance of class as a project listener
-logger <classname> the class which it to perform logging
-projecthelp print project help information
-quiet be extra quiet
-verbose be extra verbose
-version print the version information and exit
If you also require to have a usage statement printed
then calling formatter.printHelp( "ant", options, true )
will generate a usage statment as well as the help information.
One of the most widely used command line applications in the *nix world
is ls. Due to the large number of options required for ls
this example will only cover a small proportion of the options. The following
is a section of the help output.
Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).
Sort entries alphabetically if none of -cftuSUX nor --sort.
-a, --all do not hide entries starting with .
-A, --almost-all do not list implied . and ..
-b, --escape print octal escapes for nongraphic characters
--block-size=SIZE use SIZE-byte blocks
-B, --ignore-backups do not list implied entries ending with ~
-c with -lt: sort by, and show, ctime (time of last
modification of file status information)
with -l: show ctime and sort by name
otherwise: sort by ctime
-C list entries by columns
The following is the code that is used to create the
Options for this example.
// create the command line parser
CommandLineParser parser = new DefaultParser();
// create the Options
Options options = new Options();
options.addOption( "a", "all", false, "do not hide entries starting with ." );
options.addOption( "A", "almost-all", false, "do not list implied . and .." );
options.addOption( "b", "escape", false, "print octal escapes for nongraphic "
+ "characters" );
options.addOption( OptionBuilder.withLongOpt( "block-size" )
.withDescription( "use SIZE-byte blocks" )
.hasArg()
.withArgName("SIZE")
.create() );
options.addOption( "B", "ignore-backups", false, "do not list implied entried "
+ "ending with ~");
options.addOption( "c", false, "with -lt: sort by, and show, ctime (time of last "
+ "modification of file status information) with "
+ "-l:show ctime and sort by name otherwise: sort "
+ "by ctime" );
options.addOption( "C", false, "list entries by columns" );
String[] args = new String[]{ "--block-size=10" };
try {
// parse the command line arguments
CommandLine line = parser.parse( options, args );
// validate that block-size has been set
if( line.hasOption( "block-size" ) ) {
// print the value of block-size
System.out.println( line.getOptionValue( "block-size" ) );
}
}
catch( ParseException exp ) {
System.out.println( "Unexpected exception:" + exp.getMessage() );
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/ApplicationTest.java 0100644 0000765 0000024 00000041554 12537250704 030063 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.PrintWriter;
import java.io.StringWriter;
import org.junit.Test;
/**
* This is a collection of tests that test real world applications command lines.
*
*
* The following applications are tested:
*
* ls
* Ant
* Groovy
* man
*
*
*/
@SuppressWarnings("deprecation") // tests some deprecated classes
public class ApplicationTest
{
@Test
public void testLs() throws Exception {
// create the command line parser
CommandLineParser parser = new PosixParser();
Options options = new Options();
options.addOption( "a", "all", false, "do not hide entries starting with ." );
options.addOption( "A", "almost-all", false, "do not list implied . and .." );
options.addOption( "b", "escape", false, "print octal escapes for nongraphic characters" );
options.addOption( OptionBuilder.withLongOpt( "block-size" )
.withDescription( "use SIZE-byte blocks" )
.hasArg()
.withArgName("SIZE")
.create() );
options.addOption( "B", "ignore-backups", false, "do not list implied entried ending with ~");
options.addOption( "c", false, "with -lt: sort by, and show, ctime (time of last modification of file status information) with -l:show ctime and sort by name otherwise: sort by ctime" );
options.addOption( "C", false, "list entries by columns" );
String[] args = new String[]{ "--block-size=10" };
CommandLine line = parser.parse( options, args );
assertTrue( line.hasOption( "block-size" ) );
assertEquals( line.getOptionValue( "block-size" ), "10" );
}
/**
* Ant test
*/
@Test
public void testAnt() throws Exception {
// use the GNU parser
CommandLineParser parser = new GnuParser( );
Options options = new Options();
options.addOption( "help", false, "print this message" );
options.addOption( "projecthelp", false, "print project help information" );
options.addOption( "version", false, "print the version information and exit" );
options.addOption( "quiet", false, "be extra quiet" );
options.addOption( "verbose", false, "be extra verbose" );
options.addOption( "debug", false, "print debug information" );
options.addOption( "logfile", true, "use given file for log" );
options.addOption( "logger", true, "the class which is to perform the logging" );
options.addOption( "listener", true, "add an instance of a class as a project listener" );
options.addOption( "buildfile", true, "use given buildfile" );
options.addOption( OptionBuilder.withDescription( "use value for given property" )
.hasArgs()
.withValueSeparator()
.create( 'D' ) );
//, null, true, , false, true );
options.addOption( "find", true, "search for buildfile towards the root of the filesystem and use it" );
String[] args = new String[]{ "-buildfile", "mybuild.xml",
"-Dproperty=value", "-Dproperty1=value1",
"-projecthelp" };
CommandLine line = parser.parse( options, args );
// check multiple values
String[] opts = line.getOptionValues( "D" );
assertEquals( "property", opts[0] );
assertEquals( "value", opts[1] );
assertEquals( "property1", opts[2] );
assertEquals( "value1", opts[3] );
// check single value
assertEquals( line.getOptionValue( "buildfile"), "mybuild.xml" );
// check option
assertTrue( line.hasOption( "projecthelp") );
}
@Test
public void testGroovy() throws Exception {
Options options = new Options();
options.addOption(
OptionBuilder.withLongOpt("define").
withDescription("define a system property").
hasArg(true).
withArgName("name=value").
create('D'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("usage information")
.withLongOpt("help")
.create('h'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("debug mode will print out full stack traces")
.withLongOpt("debug")
.create('d'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("display the Groovy and JVM versions")
.withLongOpt("version")
.create('v'));
options.addOption(
OptionBuilder.withArgName("charset")
.hasArg()
.withDescription("specify the encoding of the files")
.withLongOpt("encoding")
.create('c'));
options.addOption(
OptionBuilder.withArgName("script")
.hasArg()
.withDescription("specify a command line script")
.create('e'));
options.addOption(
OptionBuilder.withArgName("extension")
.hasOptionalArg()
.withDescription("modify files in place; create backup if extension is given (e.g. \'.bak\')")
.create('i'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line using implicit 'line' variable")
.create('n'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line and print result (see also -n)")
.create('p'));
options.addOption(
OptionBuilder.withArgName("port")
.hasOptionalArg()
.withDescription("listen on a port and process inbound lines")
.create('l'));
options.addOption(
OptionBuilder.withArgName("splitPattern")
.hasOptionalArg()
.withDescription("split lines using splitPattern (default '\\s') using implicit 'split' variable")
.withLongOpt("autosplit")
.create('a'));
Parser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-e", "println 'hello'" }, true);
assertTrue(line.hasOption('e'));
assertEquals("println 'hello'", line.getOptionValue('e'));
}
/**
* author Slawek Zachcial
*/
@Test
public void testMan()
{
String cmdLine =
"man [-c|-f|-k|-w|-tZT device] [-adlhu7V] [-Mpath] [-Ppager] [-Slist] " +
"[-msystem] [-pstring] [-Llocale] [-eextension] [section] page ...";
Options options = new Options().
addOption("a", "all", false, "find all matching manual pages.").
addOption("d", "debug", false, "emit debugging messages.").
addOption("e", "extension", false, "limit search to extension type 'extension'.").
addOption("f", "whatis", false, "equivalent to whatis.").
addOption("k", "apropos", false, "equivalent to apropos.").
addOption("w", "location", false, "print physical location of man page(s).").
addOption("l", "local-file", false, "interpret 'page' argument(s) as local filename(s)").
addOption("u", "update", false, "force a cache consistency check.").
//FIXME - should generate -r,--prompt string
addOption("r", "prompt", true, "provide 'less' pager with prompt.").
addOption("c", "catman", false, "used by catman to reformat out of date cat pages.").
addOption("7", "ascii", false, "display ASCII translation or certain latin1 chars.").
addOption("t", "troff", false, "use troff format pages.").
//FIXME - should generate -T,--troff-device device
addOption("T", "troff-device", true, "use groff with selected device.").
addOption("Z", "ditroff", false, "use groff with selected device.").
addOption("D", "default", false, "reset all options to their default values.").
//FIXME - should generate -M,--manpath path
addOption("M", "manpath", true, "set search path for manual pages to 'path'.").
//FIXME - should generate -P,--pager pager
addOption("P", "pager", true, "use program 'pager' to display output.").
//FIXME - should generate -S,--sections list
addOption("S", "sections", true, "use colon separated section list.").
//FIXME - should generate -m,--systems system
addOption("m", "systems", true, "search for man pages from other unix system(s).").
//FIXME - should generate -L,--locale locale
addOption("L", "locale", true, "define the locale for this particular man search.").
//FIXME - should generate -p,--preprocessor string
addOption("p", "preprocessor", true, "string indicates which preprocessor to run.\n" +
" e - [n]eqn p - pic t - tbl\n" +
" g - grap r - refer v - vgrind").
addOption("V", "version", false, "show version.").
addOption("h", "help", false, "show this usage message.");
HelpFormatter hf = new HelpFormatter();
final String EOL = System.getProperty("line.separator");
StringWriter out = new StringWriter();
hf.printHelp(new PrintWriter(out), 60, cmdLine, null, options, HelpFormatter.DEFAULT_LEFT_PAD, HelpFormatter.DEFAULT_DESC_PAD, null, false);
assertEquals("usage: man [-c|-f|-k|-w|-tZT device] [-adlhu7V] [-Mpath]" + EOL +
" [-Ppager] [-Slist] [-msystem] [-pstring]" + EOL +
" [-Llocale] [-eextension] [section] page ..." + EOL +
" -7,--ascii display ASCII translation or" + EOL +
" certain latin1 chars." + EOL +
" -a,--all find all matching manual pages." + EOL +
" -c,--catman used by catman to reformat out of" + EOL +
" date cat pages." + EOL +
" -d,--debug emit debugging messages." + EOL +
" -D,--default reset all options to their" + EOL +
" default values." + EOL +
" -e,--extension limit search to extension type" + EOL +
" 'extension'." + EOL +
" -f,--whatis equivalent to whatis." + EOL +
" -h,--help show this usage message." + EOL +
" -k,--apropos equivalent to apropos." + EOL +
" -l,--local-file interpret 'page' argument(s) as" + EOL +
" local filename(s)" + EOL +
" -L,--locale define the locale for this" + EOL +
" particular man search." + EOL +
" -M,--manpath set search path for manual pages" + EOL +
" to 'path'." + EOL +
" -m,--systems search for man pages from other" + EOL +
" unix system(s)." + EOL +
" -P,--pager use program 'pager' to display" + EOL +
" output." + EOL +
" -p,--preprocessor string indicates which" + EOL +
" preprocessor to run." + EOL +
" e - [n]eqn p - pic t - tbl" + EOL +
" g - grap r - refer v -" + EOL +
" vgrind" + EOL +
" -r,--prompt provide 'less' pager with prompt." + EOL +
" -S,--sections use colon separated section list." + EOL +
" -t,--troff use troff format pages." + EOL +
" -T,--troff-device use groff with selected device." + EOL +
" -u,--update force a cache consistency check." + EOL +
" -V,--version show version." + EOL +
" -w,--location print physical location of man" + EOL +
" page(s)." + EOL +
" -Z,--ditroff use groff with selected device." + EOL,
out.toString());
}
/**
* Real world test with long and short options.
*/
@Test
public void testNLT() throws Exception {
Option help = new Option("h", "help", false, "print this message");
Option version = new Option("v", "version", false, "print version information");
Option newRun = new Option("n", "new", false, "Create NLT cache entries only for new items");
Option trackerRun = new Option("t", "tracker", false, "Create NLT cache entries only for tracker items");
Option timeLimit = OptionBuilder.withLongOpt("limit").hasArg()
.withValueSeparator()
.withDescription("Set time limit for execution, in minutes")
.create("l");
Option age = OptionBuilder.withLongOpt("age").hasArg()
.withValueSeparator()
.withDescription("Age (in days) of cache item before being recomputed")
.create("a");
Option server = OptionBuilder.withLongOpt("server").hasArg()
.withValueSeparator()
.withDescription("The NLT server address")
.create("s");
Option numResults = OptionBuilder.withLongOpt("results").hasArg()
.withValueSeparator()
.withDescription("Number of results per item")
.create("r");
Option configFile = OptionBuilder.withLongOpt("file").hasArg()
.withValueSeparator()
.withDescription("Use the specified configuration file")
.create();
Options options = new Options();
options.addOption(help);
options.addOption(version);
options.addOption(newRun);
options.addOption(trackerRun);
options.addOption(timeLimit);
options.addOption(age);
options.addOption(server);
options.addOption(numResults);
options.addOption(configFile);
// create the command line parser
CommandLineParser parser = new PosixParser();
String[] args = new String[] {
"-v",
"-l",
"10",
"-age",
"5",
"-file",
"filename"
};
CommandLine line = parser.parse(options, args);
assertTrue(line.hasOption("v"));
assertEquals(line.getOptionValue("l"), "10");
assertEquals(line.getOptionValue("limit"), "10");
assertEquals(line.getOptionValue("a"), "5");
assertEquals(line.getOptionValue("age"), "5");
assertEquals(line.getOptionValue("file"), "filename");
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/ArgumentIsOptionTest.java 0100644 0000765 0000024 00000005454 12537250704 031066 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class ArgumentIsOptionTest
{
private Options options = null;
private CommandLineParser parser = null;
@Before
public void setUp()
{
options = new Options().addOption("p", false, "Option p").addOption("attr", true, "Option accepts argument");
parser = new PosixParser();
}
@Test
public void testOptionAndOptionWithArgument() throws Exception
{
String[] args = new String[]{
"-p",
"-attr",
"p"
};
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm -p is set", cl.hasOption("p"));
assertTrue("Confirm -attr is set", cl.hasOption("attr"));
assertTrue("Confirm arg of -attr", cl.getOptionValue("attr").equals("p"));
assertTrue("Confirm all arguments recognized", cl.getArgs().length == 0);
}
@Test
public void testOptionWithArgument() throws Exception
{
String[] args = new String[]{
"-attr",
"p"
};
CommandLine cl = parser.parse(options, args);
assertFalse("Confirm -p is set", cl.hasOption("p"));
assertTrue("Confirm -attr is set", cl.hasOption("attr"));
assertTrue("Confirm arg of -attr",
cl.getOptionValue("attr").equals("p"));
assertTrue("Confirm all arguments recognized", cl.getArgs().length == 0);
}
@Test
public void testOption() throws Exception
{
String[] args = new String[]{
"-p"
};
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm -p is set", cl.hasOption("p"));
assertFalse("Confirm -attr is not set", cl.hasOption("attr"));
assertTrue("Confirm all arguments recognized", cl.getArgs().length == 0);
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/BasicParserTest.java 0100644 0000765 0000024 00000010333 12537250704 030005 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import org.junit.Before;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class BasicParserTest extends ParserTestCase
{
@Before
public void setUp()
{
super.setUp();
parser = new BasicParser();
}
@Override
public void testDoubleDash2() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testLongWithoutEqualSingleDash() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testAmbiguousLongWithoutEqualSingleDash() throws Exception
{
// not supported by the basicParser
}
@Override
public void testNegativeOption() throws Exception
{
// not supported by the BasicParser (CLI-184)
}
@Override
public void testPropertiesOption1() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testPropertiesOption2() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testShortWithEqual() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testShortWithoutEqual() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testLongWithEqualDoubleDash() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testLongWithEqualSingleDash() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testUnambiguousPartialLongOption1() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testUnambiguousPartialLongOption2() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testUnambiguousPartialLongOption3() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testUnambiguousPartialLongOption4() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testAmbiguousPartialLongOption1() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testAmbiguousPartialLongOption2() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testAmbiguousPartialLongOption3() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testAmbiguousPartialLongOption4() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testPartialLongOptionSingleDash() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testBursting() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testUnrecognizedOptionWithBursting() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testMissingArgWithBursting() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testStopBursting() throws Exception
{
// not supported by the BasicParser
}
@Override
public void testStopBursting2() throws Exception
{
// not supported by the BasicParser
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/bug/BugCLI133Test.java 0100644 0000765 0000024 00000003034 12537250704 027660 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli.bug;
import static org.junit.Assert.assertFalse;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class BugCLI133Test
{
@Test
public void testOrder() throws ParseException {
Option optionA = new Option("a", "first");
Options opts = new Options();
opts.addOption(optionA);
PosixParser posixParser = new PosixParser();
CommandLine line = posixParser.parse(opts, null);
assertFalse(line.hasOption(null));
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/bug/BugCLI13Test.java 0100644 0000765 0000024 00000004051 12537250704 027575 0 ustar 00bene staff 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli.bug;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class BugCLI13Test
{
@Test
public void testCLI13() throws ParseException
{
final String debugOpt = "debug";
@SuppressWarnings("static-access")
Option debug = OptionBuilder
.withArgName( debugOpt )
.withDescription( "turn on debugging" )
.withLongOpt( debugOpt )
.hasArg()
.create( 'd' );
Options options = new Options();
options.addOption( debug );
CommandLine commandLine = new PosixParser().parse( options, new String[]{"-d", "true"} );
assertEquals("true", commandLine.getOptionValue( debugOpt ));
assertEquals("true", commandLine.getOptionValue( 'd' ));
assertTrue(commandLine.hasOption( 'd'));
assertTrue(commandLine.hasOption( debugOpt));
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/bug/BugCLI148Test.java 0100644 0000765 0000024 00000004240 12537250704 027666 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli.bug;
import static org.junit.Assert.assertEquals;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.PosixParser;
import org.junit.Before;
import org.junit.Test;
/**
* http://issues.apache.org/jira/browse/CLI-148
*/
@SuppressWarnings("deprecation") // tests some deprecated classes
public class BugCLI148Test
{
private Options options;
@Before
public void setUp() throws Exception
{
options = new Options();
options.addOption(OptionBuilder.hasArg().create('t'));
options.addOption(OptionBuilder.hasArg().create('s'));
}
@Test
public void testWorkaround1() throws Exception
{
CommandLineParser parser = new PosixParser();
String[] args = new String[]{ "-t-something" };
CommandLine commandLine = parser.parse(options, args);
assertEquals("-something", commandLine.getOptionValue('t'));
}
@Test
public void testWorkaround2() throws Exception
{
CommandLineParser parser = new PosixParser();
String[] args = new String[]{ "-t", "\"-something\"" };
CommandLine commandLine = parser.parse(options, args);
assertEquals("-something", commandLine.getOptionValue('t'));
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/bug/BugCLI162Test.java 0100644 0000765 0000024 00000043175 12537250704 027674 0 ustar 00bene staff 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli.bug;
import static org.junit.Assert.assertEquals;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.sql.ParameterMetaData;
import java.sql.Types;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionGroup;
import org.apache.commons.cli.Options;
import org.junit.Before;
import org.junit.Test;
public class BugCLI162Test
{
/** Constant for the line separator.*/
private static final String CR = System.getProperty("line.separator");
private HelpFormatter formatter;
private StringWriter sw;
@Before
public void setUp() throws Exception
{
formatter = new HelpFormatter();
sw = new StringWriter();
}
@Test
public void testInfiniteLoop() {
Options options = new Options();
options.addOption("h", "help", false, "This is a looooong description");
// used to hang & crash
formatter.printHelp(new PrintWriter(sw), 20, "app", null, options, HelpFormatter.DEFAULT_LEFT_PAD, HelpFormatter.DEFAULT_DESC_PAD, null);
String expected = "usage: app" + CR +
" -h,--help This is" + CR +
" a" + CR +
" looooon" + CR +
" g" + CR +
" descrip" + CR +
" tion" + CR;
assertEquals(expected, sw.toString());
}
@Test
public void testPrintHelpLongLines() {
// Constants used for options
final String OPT = "-";
final String OPT_COLUMN_NAMES = "l";
final String OPT_CONNECTION = "c";
final String OPT_DESCRIPTION = "e";
final String OPT_DRIVER = "d";
final String OPT_DRIVER_INFO = "n";
final String OPT_FILE_BINDING = "b";
final String OPT_FILE_JDBC = "j";
final String OPT_FILE_SFMD = "f";
final String OPT_HELP = "h";
final String OPT_HELP_ = "help";
final String OPT_INTERACTIVE = "i";
final String OPT_JDBC_TO_SFMD = "2";
final String OPT_JDBC_TO_SFMD_L = "jdbc2sfmd";
final String OPT_METADATA = "m";
final String OPT_PARAM_MODES_INT = "o";
final String OPT_PARAM_MODES_NAME = "O";
final String OPT_PARAM_NAMES = "a";
final String OPT_PARAM_TYPES_INT = "y";
final String OPT_PARAM_TYPES_NAME = "Y";
final String OPT_PASSWORD = "p";
final String OPT_PASSWORD_L = "password";
final String OPT_SQL = "s";
final String OPT_SQL_L = "sql";
final String OPT_SQL_SPLIT_DEFAULT = "###";
final String OPT_SQL_SPLIT_L = "splitSql";
final String OPT_STACK_TRACE = "t";
final String OPT_TIMING = "g";
final String OPT_TRIM_L = "trim";
final String OPT_USER = "u";
final String OPT_WRITE_TO_FILE = "w";
final String _PMODE_IN = "IN";
final String _PMODE_INOUT = "INOUT";
final String _PMODE_OUT = "OUT";
final String _PMODE_UNK = "Unknown";
final String PMODES = _PMODE_IN + ", " + _PMODE_INOUT + ", " + _PMODE_OUT + ", " + _PMODE_UNK;
// Options build
Options commandLineOptions;
commandLineOptions = new Options();
commandLineOptions.addOption(OPT_HELP, OPT_HELP_, false, "Prints help and quits");
commandLineOptions.addOption(OPT_DRIVER, "driver", true, "JDBC driver class name");
commandLineOptions.addOption(OPT_DRIVER_INFO, "info", false, "Prints driver information and properties. If "
+ OPT
+ OPT_CONNECTION
+ " is not specified, all drivers on the classpath are displayed.");
commandLineOptions.addOption(OPT_CONNECTION, "url", true, "Connection URL");
commandLineOptions.addOption(OPT_USER, "user", true, "A database user name");
commandLineOptions
.addOption(
OPT_PASSWORD,
OPT_PASSWORD_L,
true,
"The database password for the user specified with the "
+ OPT
+ OPT_USER
+ " option. You can obfuscate the password with org.mortbay.jetty.security.Password, see http://docs.codehaus.org/display/JETTY/Securing+Passwords");
commandLineOptions.addOption(OPT_SQL, OPT_SQL_L, true, "Runs SQL or {call stored_procedure(?, ?)} or {?=call function(?, ?)}");
commandLineOptions.addOption(OPT_FILE_SFMD, "sfmd", true, "Writes a SFMD file for the given SQL");
commandLineOptions.addOption(OPT_FILE_BINDING, "jdbc", true, "Writes a JDBC binding node file for the given SQL");
commandLineOptions.addOption(OPT_FILE_JDBC, "node", true, "Writes a JDBC node file for the given SQL (internal debugging)");
commandLineOptions.addOption(OPT_WRITE_TO_FILE, "outfile", true, "Writes the SQL output to the given file");
commandLineOptions.addOption(OPT_DESCRIPTION, "description", true,
"SFMD description. A default description is used if omited. Example: " + OPT + OPT_DESCRIPTION + " \"Runs such and such\"");
commandLineOptions.addOption(OPT_INTERACTIVE, "interactive", false,
"Runs in interactive mode, reading and writing from the console, 'go' or '/' sends a statement");
commandLineOptions.addOption(OPT_TIMING, "printTiming", false, "Prints timing information");
commandLineOptions.addOption(OPT_METADATA, "printMetaData", false, "Prints metadata information");
commandLineOptions.addOption(OPT_STACK_TRACE, "printStack", false, "Prints stack traces on errors");
Option option = new Option(OPT_COLUMN_NAMES, "columnNames", true, "Column XML names; default names column labels. Example: "
+ OPT
+ OPT_COLUMN_NAMES
+ " \"cname1 cname2\"");
commandLineOptions.addOption(option);
option = new Option(OPT_PARAM_NAMES, "paramNames", true, "Parameter XML names; default names are param1, param2, etc. Example: "
+ OPT
+ OPT_PARAM_NAMES
+ " \"pname1 pname2\"");
commandLineOptions.addOption(option);
//
OptionGroup pOutTypesOptionGroup = new OptionGroup();
String pOutTypesOptionGroupDoc = OPT + OPT_PARAM_TYPES_INT + " and " + OPT + OPT_PARAM_TYPES_NAME + " are mutually exclusive.";
final String typesClassName = Types.class.getName();
option = new Option(OPT_PARAM_TYPES_INT, "paramTypes", true, "Parameter types from "
+ typesClassName
+ ". "
+ pOutTypesOptionGroupDoc
+ " Example: "
+ OPT
+ OPT_PARAM_TYPES_INT
+ " \"-10 12\"");
commandLineOptions.addOption(option);
option = new Option(OPT_PARAM_TYPES_NAME, "paramTypeNames", true, "Parameter "
+ typesClassName
+ " names. "
+ pOutTypesOptionGroupDoc
+ " Example: "
+ OPT
+ OPT_PARAM_TYPES_NAME
+ " \"CURSOR VARCHAR\"");
commandLineOptions.addOption(option);
commandLineOptions.addOptionGroup(pOutTypesOptionGroup);
//
OptionGroup modesOptionGroup = new OptionGroup();
String modesOptionGroupDoc = OPT + OPT_PARAM_MODES_INT + " and " + OPT + OPT_PARAM_MODES_NAME + " are mutually exclusive.";
option = new Option(OPT_PARAM_MODES_INT, "paramModes", true, "Parameters modes ("
+ ParameterMetaData.parameterModeIn
+ "=IN, "
+ ParameterMetaData.parameterModeInOut
+ "=INOUT, "
+ ParameterMetaData.parameterModeOut
+ "=OUT, "
+ ParameterMetaData.parameterModeUnknown
+ "=Unknown"
+ "). "
+ modesOptionGroupDoc
+ " Example for 2 parameters, OUT and IN: "
+ OPT
+ OPT_PARAM_MODES_INT
+ " \""
+ ParameterMetaData.parameterModeOut
+ " "
+ ParameterMetaData.parameterModeIn
+ "\"");
modesOptionGroup.addOption(option);
option = new Option(OPT_PARAM_MODES_NAME, "paramModeNames", true, "Parameters mode names ("
+ PMODES
+ "). "
+ modesOptionGroupDoc
+ " Example for 2 parameters, OUT and IN: "
+ OPT
+ OPT_PARAM_MODES_NAME
+ " \""
+ _PMODE_OUT
+ " "
+ _PMODE_IN
+ "\"");
modesOptionGroup.addOption(option);
commandLineOptions.addOptionGroup(modesOptionGroup);
option = new Option(null, OPT_TRIM_L, true,
"Trims leading and trailing spaces from all column values. Column XML names can be optionally specified to set which columns to trim.");
option.setOptionalArg(true);
commandLineOptions.addOption(option);
option = new Option(OPT_JDBC_TO_SFMD, OPT_JDBC_TO_SFMD_L, true,
"Converts the JDBC file in the first argument to an SMFD file specified in the second argument.");
option.setArgs(2);
commandLineOptions.addOption(option);
formatter.printHelp(new PrintWriter(sw), HelpFormatter.DEFAULT_WIDTH, this.getClass().getName(), null, commandLineOptions, HelpFormatter.DEFAULT_LEFT_PAD, HelpFormatter.DEFAULT_DESC_PAD, null);
String expected = "usage: org.apache.commons.cli.bug.BugCLI162Test" + CR +
" -2,--jdbc2sfmd Converts the JDBC file in the first argument" + CR +
" to an SMFD file specified in the second" + CR +
" argument." + CR +
" -a,--paramNames Parameter XML names; default names are" + CR +
" param1, param2, etc. Example: -a \"pname1" + CR +
" pname2\"" + CR +
" -b,--jdbc Writes a JDBC binding node file for the given" + CR +
" SQL" + CR +
" -c,--url Connection URL" + CR +
" -d,--driver JDBC driver class name" + CR +
" -e,--description SFMD description. A default description is" + CR +
" used if omited. Example: -e \"Runs such and" + CR +
" such\"" + CR +
" -f,--sfmd Writes a SFMD file for the given SQL" + CR +
" -g,--printTiming Prints timing information" + CR +
" -h,--help Prints help and quits" + CR +
" -i,--interactive Runs in interactive mode, reading and writing" + CR +
" from the console, 'go' or '/' sends a" + CR +
" statement" + CR +
" -j,--node Writes a JDBC node file for the given SQL" + CR +
" (internal debugging)" + CR +
" -l,--columnNames Column XML names; default names column" + CR +
" labels. Example: -l \"cname1 cname2\"" + CR +
" -m,--printMetaData Prints metadata information" + CR +
" -n,--info Prints driver information and properties. If" + CR +
" -c is not specified, all drivers on the" + CR +
" classpath are displayed." + CR +
" -o,--paramModes Parameters modes (1=IN, 2=INOUT, 4=OUT," + CR +
" 0=Unknown). -o and -O are mutually exclusive." + CR +
" Example for 2 parameters, OUT and IN: -o \"4" + CR +
" 1\"" + CR +
" -O,--paramModeNames Parameters mode names (IN, INOUT, OUT," + CR +
" Unknown). -o and -O are mutually exclusive." + CR +
" Example for 2 parameters, OUT and IN: -O \"OUT" + CR +
" IN\"" + CR +
" -p,--password The database password for the user specified" + CR +
" with the -u option. You can obfuscate the" + CR +
" password with" + CR +
" org.mortbay.jetty.security.Password, see" + CR +
" http://docs.codehaus.org/display/JETTY/Securi" + CR +
" ng+Passwords" + CR +
" -s,--sql Runs SQL or {call stored_procedure(?, ?)} or" + CR +
" {?=call function(?, ?)}" + CR +
" -t,--printStack Prints stack traces on errors" + CR +
" --trim Trims leading and trailing spaces from all" + CR +
" column values. Column XML names can be" + CR +
" optionally specified to set which columns to" + CR +
" trim." + CR +
" -u,--user A database user name" + CR +
" -w,--outfile Writes the SQL output to the given file" + CR +
" -y,--paramTypes Parameter types from java.sql.Types. -y and" + CR +
" -Y are mutually exclusive. Example: -y \"-10" + CR +
" 12\"" + CR +
" -Y,--paramTypeNames Parameter java.sql.Types names. -y and -Y are" + CR +
" mutually exclusive. Example: -Y \"CURSOR" + CR +
" VARCHAR\"" + CR;
assertEquals(expected, sw.toString());
}
@Test
public void testLongLineChunking() {
Options options = new Options();
options.addOption("x", "extralongarg", false,
"This description has ReallyLongValuesThatAreLongerThanTheWidthOfTheColumns " +
"and also other ReallyLongValuesThatAreHugerAndBiggerThanTheWidthOfTheColumnsBob, " +
"yes. ");
formatter.printHelp(new PrintWriter(sw), 35, this.getClass().getName(), "Header", options, 0, 5, "Footer");
String expected = "usage:" + CR +
" org.apache.commons.cli.bug.B" + CR +
" ugCLI162Test" + CR +
"Header" + CR +
"-x,--extralongarg This" + CR +
" description" + CR +
" has" + CR +
" ReallyLongVal" + CR +
" uesThatAreLon" + CR +
" gerThanTheWid" + CR +
" thOfTheColumn" + CR +
" s and also" + CR +
" other" + CR +
" ReallyLongVal" + CR +
" uesThatAreHug" + CR +
" erAndBiggerTh" + CR +
" anTheWidthOfT" + CR +
" heColumnsBob," + CR +
" yes." + CR +
"Footer" + CR;
assertEquals( "Long arguments did not split as expected", expected, sw.toString() );
}
@Test
public void testLongLineChunkingIndentIgnored() {
Options options = new Options();
options.addOption("x", "extralongarg", false, "This description is Long." );
formatter.printHelp(new PrintWriter(sw), 22, this.getClass().getName(), "Header", options, 0, 5, "Footer");
String expected = "usage:" + CR +
" org.apache.comm" + CR +
" ons.cli.bug.Bug" + CR +
" CLI162Test" + CR +
"Header" + CR +
"-x,--extralongarg" + CR +
" This description is" + CR +
" Long." + CR +
"Footer" + CR;
assertEquals( "Long arguments did not split as expected", expected, sw.toString() );
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/bug/BugCLI18Test.java 0100644 0000765 0000024 00000003635 12537250704 027611 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli.bug;
import java.io.PrintWriter;
import java.io.StringWriter;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.junit.Test;
/**
* http://issues.apache.org/jira/browse/CLI-18
*/
public class BugCLI18Test
{
@Test
public void testCLI18()
{
Options options = new Options();
options.addOption(new Option("a", "aaa", false, "aaaaaaa"));
options.addOption(new Option(null, "bbb", false, "bbbbbbb dksh fkshd fkhs dkfhsdk fhskd hksdks dhfowehfsdhfkjshf skfhkshf sf jkshfk sfh skfh skf f"));
options.addOption(new Option("c", null, false, "ccccccc"));
HelpFormatter formatter = new HelpFormatter();
StringWriter out = new StringWriter();
formatter.printHelp(new PrintWriter(out), 80, "foobar", "dsfkfsh kdh hsd hsdh fkshdf ksdh fskdh fsdh fkshfk sfdkjhskjh fkjh fkjsh khsdkj hfskdhf skjdfh ksf khf s", options, 2, 2, "blort j jgj j jg jhghjghjgjhgjhg jgjhgj jhg jhg hjg jgjhghjg jhg hjg jhgjg jgjhghjg jg jgjhgjgjg jhg jhgjh" + '\r' + '\n' + "rarrr", true);
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/bug/BugCLI252Test.java 0100644 0000765 0000024 00000003043 12537250704 027662 0 ustar 00bene staff 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli.bug;
import org.apache.commons.cli.*;
import org.junit.Test;
public class BugCLI252Test extends DefaultParserTest {
@Test
public void testExactOptionNameMatch() throws ParseException {
new DefaultParser().parse(getOptions(), new String[]{"--prefix"});
}
@Test(expected = AmbiguousOptionException.class)
public void testAmbiquousOptionName() throws ParseException {
new DefaultParser().parse(getOptions(), new String[]{"--pref"});
}
private Options getOptions() {
Options options = new Options();
options.addOption(Option.builder().longOpt("prefix").build());
options.addOption(Option.builder().longOpt("prefixplusplus").build());
return options;
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/bug/BugCLI71Test.java 0100644 0000765 0000024 00000006462 12537250704 027611 0 ustar 00bene staff 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli.bug;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.MissingArgumentException;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.PosixParser;
import org.junit.Before;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class BugCLI71Test
{
private Options options;
private CommandLineParser parser;
@Before
public void setUp() {
options = new Options();
Option algorithm = new Option("a" , "algo", true, "the algorithm which it to perform executing");
algorithm.setArgName("algorithm name");
options.addOption(algorithm);
Option key = new Option("k" , "key", true, "the key the setted algorithm uses to process");
algorithm.setArgName("value");
options.addOption(key);
parser = new PosixParser();
}
@Test
public void testBasic() throws Exception {
String[] args = new String[] { "-a", "Caesar", "-k", "A" };
CommandLine line = parser.parse( options, args);
assertEquals( "Caesar", line.getOptionValue("a") );
assertEquals( "A", line.getOptionValue("k") );
}
@Test
public void testMistakenArgument() throws Exception {
String[] args = new String[] { "-a", "Caesar", "-k", "A" };
CommandLine line = parser.parse( options, args);
args = new String[] { "-a", "Caesar", "-k", "a" };
line = parser.parse( options, args);
assertEquals( "Caesar", line.getOptionValue("a") );
assertEquals( "a", line.getOptionValue("k") );
}
@Test
public void testLackOfError() throws Exception {
String[] args = new String[] { "-k", "-a", "Caesar" };
try {
parser.parse( options, args);
fail("MissingArgumentException expected");
} catch(MissingArgumentException e) {
assertEquals("option missing an argument", "k", e.getOption().getOpt());
}
}
@Test
public void testGetsDefaultIfOptional() throws Exception {
String[] args = new String[] { "-k", "-a", "Caesar" };
options.getOption("k").setOptionalArg(true);
CommandLine line = parser.parse( options, args);
assertEquals( "Caesar", line.getOptionValue("a") );
assertEquals( "a", line.getOptionValue('k', "a") );
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/bug/BugsTest.java 0100644 0000765 0000024 00000030233 12537250704 027265 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli.bug;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.Iterator;
import java.util.Properties;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.MissingArgumentException;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.OptionGroup;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.Parser;
import org.apache.commons.cli.PosixParser;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class BugsTest
{
@Test
public void test11457() throws Exception
{
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("verbose").create());
String[] args = new String[]{"--verbose"};
CommandLineParser parser = new PosixParser();
CommandLine cmd = parser.parse(options, args);
assertTrue(cmd.hasOption("verbose"));
}
@Test
public void test11458() throws Exception
{
Options options = new Options();
options.addOption( OptionBuilder.withValueSeparator( '=' ).hasArgs().create( 'D' ) );
options.addOption( OptionBuilder.withValueSeparator( ':' ).hasArgs().create( 'p' ) );
String[] args = new String[] { "-DJAVA_HOME=/opt/java" , "-pfile1:file2:file3" };
CommandLineParser parser = new PosixParser();
CommandLine cmd = parser.parse(options, args);
String[] values = cmd.getOptionValues('D');
assertEquals(values[0], "JAVA_HOME");
assertEquals(values[1], "/opt/java");
values = cmd.getOptionValues('p');
assertEquals(values[0], "file1");
assertEquals(values[1], "file2");
assertEquals(values[2], "file3");
Iterator iter = cmd.iterator();
while (iter.hasNext())
{
Option opt = iter.next();
switch (opt.getId())
{
case 'D':
assertEquals(opt.getValue(0), "JAVA_HOME");
assertEquals(opt.getValue(1), "/opt/java");
break;
case 'p':
assertEquals(opt.getValue(0), "file1");
assertEquals(opt.getValue(1), "file2");
assertEquals(opt.getValue(2), "file3");
break;
default:
fail("-D option not found");
}
}
}
@Test
public void test11680() throws Exception
{
Options options = new Options();
options.addOption("f", true, "foobar");
options.addOption("m", true, "missing");
String[] args = new String[]{"-f", "foo"};
CommandLineParser parser = new PosixParser();
CommandLine cmd = parser.parse(options, args);
cmd.getOptionValue("f", "default f");
cmd.getOptionValue("m", "default m");
}
@Test
public void test11456() throws Exception
{
// Posix
Options options = new Options();
options.addOption( OptionBuilder.hasOptionalArg().create( 'a' ) );
options.addOption( OptionBuilder.hasArg().create( 'b' ) );
String[] args = new String[] { "-a", "-bvalue" };
CommandLineParser parser = new PosixParser();
CommandLine cmd = parser.parse( options, args );
assertEquals( cmd.getOptionValue( 'b' ), "value" );
// GNU
options = new Options();
options.addOption( OptionBuilder.hasOptionalArg().create( 'a' ) );
options.addOption( OptionBuilder.hasArg().create( 'b' ) );
args = new String[] { "-a", "-b", "value" };
parser = new GnuParser();
cmd = parser.parse( options, args );
assertEquals( cmd.getOptionValue( 'b' ), "value" );
}
@Test
public void test12210() throws Exception
{
// create the main options object which will handle the first parameter
Options mainOptions = new Options();
// There can be 2 main exclusive options: -exec|-rep
// Therefore, place them in an option group
String[] argv = new String[] { "-exec", "-exec_opt1", "-exec_opt2" };
OptionGroup grp = new OptionGroup();
grp.addOption(new Option("exec",false,"description for this option"));
grp.addOption(new Option("rep",false,"description for this option"));
mainOptions.addOptionGroup(grp);
// for the exec option, there are 2 options...
Options execOptions = new Options();
execOptions.addOption("exec_opt1", false, " desc");
execOptions.addOption("exec_opt2", false, " desc");
// similarly, for rep there are 2 options...
Options repOptions = new Options();
repOptions.addOption("repopto", false, "desc");
repOptions.addOption("repoptt", false, "desc");
// create the parser
GnuParser parser = new GnuParser();
// finally, parse the arguments:
// first parse the main options to see what the user has specified
// We set stopAtNonOption to true so it does not touch the remaining
// options
CommandLine cmd = parser.parse(mainOptions,argv,true);
// get the remaining options...
argv = cmd.getArgs();
if(cmd.hasOption("exec"))
{
cmd = parser.parse(execOptions,argv,false);
// process the exec_op1 and exec_opt2...
assertTrue( cmd.hasOption("exec_opt1") );
assertTrue( cmd.hasOption("exec_opt2") );
}
else if(cmd.hasOption("rep"))
{
cmd = parser.parse(repOptions,argv,false);
// process the rep_op1 and rep_opt2...
}
else {
fail( "exec option not found" );
}
}
@Test
public void test13425() throws Exception
{
Options options = new Options();
Option oldpass = OptionBuilder.withLongOpt( "old-password" )
.withDescription( "Use this option to specify the old password" )
.hasArg()
.create( 'o' );
Option newpass = OptionBuilder.withLongOpt( "new-password" )
.withDescription( "Use this option to specify the new password" )
.hasArg()
.create( 'n' );
String[] args = {
"-o",
"-n",
"newpassword"
};
options.addOption( oldpass );
options.addOption( newpass );
Parser parser = new PosixParser();
try {
parser.parse( options, args );
fail( "MissingArgumentException not caught." );
} catch( MissingArgumentException expected ) {
}
}
@Test
public void test13666() throws Exception
{
Options options = new Options();
Option dir = OptionBuilder.withDescription( "dir" ).hasArg().create( 'd' );
options.addOption( dir );
final PrintStream oldSystemOut = System.out;
try
{
final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
final PrintStream print = new PrintStream(bytes);
// capture this platform's eol symbol
print.println();
final String eol = bytes.toString();
bytes.reset();
System.setOut(new PrintStream(bytes));
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp( "dir", options );
assertEquals("usage: dir"+eol+" -d dir"+eol,bytes.toString());
}
finally
{
System.setOut(oldSystemOut);
}
}
@Test
public void test13935() throws Exception
{
OptionGroup directions = new OptionGroup();
Option left = new Option( "l", "left", false, "go left" );
Option right = new Option( "r", "right", false, "go right" );
Option straight = new Option( "s", "straight", false, "go straight" );
Option forward = new Option( "f", "forward", false, "go forward" );
forward.setRequired( true );
directions.addOption( left );
directions.addOption( right );
directions.setRequired( true );
Options opts = new Options();
opts.addOptionGroup( directions );
opts.addOption( straight );
CommandLineParser parser = new PosixParser();
String[] args = new String[] { };
try {
parser.parse(opts, args);
fail("Expected ParseException");
}
catch (ParseException expected) {
}
args = new String[] { "-s" };
try {
parser.parse(opts, args);
fail("Expected ParseException");
}
catch (ParseException expected) {
}
args = new String[] { "-s", "-l" };
CommandLine line = parser.parse(opts, args);
assertNotNull(line);
opts.addOption( forward );
args = new String[] { "-s", "-l", "-f" };
line = parser.parse(opts, args);
assertNotNull(line);
}
@Test
public void test14786() throws Exception
{
Option o = OptionBuilder.isRequired().withDescription("test").create("test");
Options opts = new Options();
opts.addOption(o);
opts.addOption(o);
CommandLineParser parser = new GnuParser();
String[] args = new String[] { "-test" };
CommandLine line = parser.parse( opts, args );
assertTrue( line.hasOption( "test" ) );
}
@Test
public void test15046() throws Exception
{
CommandLineParser parser = new PosixParser();
String[] CLI_ARGS = new String[] {"-z", "c"};
Options options = new Options();
options.addOption(new Option("z", "timezone", true, "affected option"));
parser.parse(options, CLI_ARGS);
//now add conflicting option
options.addOption("c", "conflict", true, "conflict option");
CommandLine line = parser.parse(options, CLI_ARGS);
assertEquals( line.getOptionValue('z'), "c" );
assertTrue( !line.hasOption("c") );
}
@Test
public void test15648() throws Exception
{
CommandLineParser parser = new PosixParser();
final String[] args = new String[] { "-m", "\"Two Words\"" };
Option m = OptionBuilder.hasArgs().create("m");
Options options = new Options();
options.addOption( m );
CommandLine line = parser.parse( options, args );
assertEquals( "Two Words", line.getOptionValue( "m" ) );
}
@Test
public void test31148() throws ParseException
{
Option multiArgOption = new Option("o","option with multiple args");
multiArgOption.setArgs(1);
Options options = new Options();
options.addOption(multiArgOption);
Parser parser = new PosixParser();
String[] args = new String[]{};
Properties props = new Properties();
props.setProperty("o","ovalue");
CommandLine cl = parser.parse(options,args,props);
assertTrue(cl.hasOption('o'));
assertEquals("ovalue",cl.getOptionValue('o'));
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/CommandLineTest.java 0100644 0000765 0000024 00000006211 12537250704 027775 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.util.Properties;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class CommandLineTest
{
@Test
public void testGetOptionProperties() throws Exception
{
String[] args = new String[] { "-Dparam1=value1", "-Dparam2=value2", "-Dparam3", "-Dparam4=value4", "-D", "--property", "foo=bar" };
Options options = new Options();
options.addOption(OptionBuilder.withValueSeparator().hasOptionalArgs(2).create('D'));
options.addOption(OptionBuilder.withValueSeparator().hasArgs(2).withLongOpt("property").create());
Parser parser = new GnuParser();
CommandLine cl = parser.parse(options, args);
Properties props = cl.getOptionProperties("D");
assertNotNull("null properties", props);
assertEquals("number of properties in " + props, 4, props.size());
assertEquals("property 1", "value1", props.getProperty("param1"));
assertEquals("property 2", "value2", props.getProperty("param2"));
assertEquals("property 3", "true", props.getProperty("param3"));
assertEquals("property 4", "value4", props.getProperty("param4"));
assertEquals("property with long format", "bar", cl.getOptionProperties("property").getProperty("foo"));
}
@Test
public void testGetOptions()
{
CommandLine cmd = new CommandLine();
assertNotNull(cmd.getOptions());
assertEquals(0, cmd.getOptions().length);
cmd.addOption(new Option("a", null));
cmd.addOption(new Option("b", null));
cmd.addOption(new Option("c", null));
assertEquals(3, cmd.getOptions().length);
}
@Test
public void testGetParsedOptionValue() throws Exception {
Options options = new Options();
options.addOption(OptionBuilder.hasArg().withType(Number.class).create("i"));
options.addOption(OptionBuilder.hasArg().create("f"));
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.parse(options, new String[] { "-i", "123", "-f", "foo" });
assertEquals(123, ((Number) cmd.getParsedOptionValue("i")).intValue());
assertEquals("foo", cmd.getParsedOptionValue("f"));
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/DefaultParserTest.java 0100644 0000765 0000024 00000002003 12537250704 030343 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import org.junit.Before;
public class DefaultParserTest extends ParserTestCase {
@Before
public void setUp() {
super.setUp();
parser = new DefaultParser();
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/GnuParserTest.java 0100644 0000765 0000024 00000007471 12537250704 027526 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import org.junit.Before;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class GnuParserTest extends ParserTestCase
{
@Before
public void setUp()
{
super.setUp();
parser = new GnuParser();
}
@Override
public void testDoubleDash2() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testLongWithoutEqualSingleDash() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testAmbiguousLongWithoutEqualSingleDash() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testNegativeOption() throws Exception
{
// not supported by the GnuParser (CLI-184)
}
@Override
public void testLongWithUnexpectedArgument1() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testLongWithUnexpectedArgument2() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testShortWithUnexpectedArgument() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testUnambiguousPartialLongOption1() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testUnambiguousPartialLongOption2() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testUnambiguousPartialLongOption3() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testUnambiguousPartialLongOption4() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testAmbiguousPartialLongOption1() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testAmbiguousPartialLongOption2() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testAmbiguousPartialLongOption3() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testAmbiguousPartialLongOption4() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testPartialLongOptionSingleDash() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testBursting() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testUnrecognizedOptionWithBursting() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testMissingArgWithBursting() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testStopBursting() throws Exception
{
// not supported by the GnuParser
}
@Override
public void testStopBursting2() throws Exception
{
// not supported by the GnuParser
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/HelpFormatterTest.java 0100644 0000765 0000024 00000054761 12537250704 030400 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Comparator;
import org.junit.Test;
/**
* Test case for the HelpFormatter class.
*/
public class HelpFormatterTest
{
private static final String EOL = System.getProperty("line.separator");
@Test
public void testFindWrapPos() throws Exception
{
HelpFormatter hf = new HelpFormatter();
String text = "This is a test.";
// text width should be max 8; the wrap position is 7
assertEquals("wrap position", 7, hf.findWrapPos(text, 8, 0));
// starting from 8 must give -1 - the wrap pos is after end
assertEquals("wrap position 2", -1, hf.findWrapPos(text, 8, 8));
// words longer than the width are cut
text = "aaaa aa";
assertEquals("wrap position 3", 3, hf.findWrapPos(text, 3, 0));
// last word length is equal to the width
text = "aaaaaa aaaaaa";
assertEquals("wrap position 4", 6, hf.findWrapPos(text, 6, 0));
assertEquals("wrap position 4", -1, hf.findWrapPos(text, 6, 7));
text = "aaaaaa\n aaaaaa";
assertEquals("wrap position 5", 7, hf.findWrapPos(text, 6, 0));
text = "aaaaaa\t aaaaaa";
assertEquals("wrap position 6", 7, hf.findWrapPos(text, 6, 0));
}
@Test
public void testRenderWrappedTextWordCut()
{
int width = 7;
int padding = 0;
String text = "Thisisatest.";
String expected = "Thisisa" + EOL +
"test.";
StringBuffer sb = new StringBuffer();
new HelpFormatter().renderWrappedText(sb, width, padding, text);
assertEquals("cut and wrap", expected, sb.toString());
}
@Test
public void testRenderWrappedTextSingleLine()
{
// single line text
int width = 12;
int padding = 0;
String text = "This is a test.";
String expected = "This is a" + EOL +
"test.";
StringBuffer sb = new StringBuffer();
new HelpFormatter().renderWrappedText(sb, width, padding, text);
assertEquals("single line text", expected, sb.toString());
}
@Test
public void testRenderWrappedTextSingleLinePadded()
{
// single line padded text
int width = 12;
int padding = 4;
String text = "This is a test.";
String expected = "This is a" + EOL +
" test.";
StringBuffer sb = new StringBuffer();
new HelpFormatter().renderWrappedText(sb, width, padding, text);
assertEquals("single line padded text", expected, sb.toString());
}
@Test
public void testRenderWrappedTextSingleLinePadded2()
{
// single line padded text 2
int width = 53;
int padding = 24;
String text = " -p,--period PERIOD is time duration of form " +
"DATE[-DATE] where DATE has form YYYY[MM[DD]]";
String expected = " -p,--period PERIOD is time duration of" + EOL +
" form DATE[-DATE] where DATE" + EOL +
" has form YYYY[MM[DD]]";
StringBuffer sb = new StringBuffer();
new HelpFormatter().renderWrappedText(sb, width, padding, text);
assertEquals("single line padded text 2", expected, sb.toString());
}
@Test
public void testRenderWrappedTextMultiLine()
{
// multi line text
int width = 16;
int padding = 0;
String expected = "aaaa aaaa aaaa" + EOL +
"aaaaaa" + EOL +
"aaaaa";
StringBuffer sb = new StringBuffer();
new HelpFormatter().renderWrappedText(sb, width, padding, expected);
assertEquals("multi line text", expected, sb.toString());
}
@Test
public void testRenderWrappedTextMultiLinePadded()
{
// multi-line padded text
int width = 16;
int padding = 4;
String text = "aaaa aaaa aaaa" + EOL +
"aaaaaa" + EOL +
"aaaaa";
String expected = "aaaa aaaa aaaa" + EOL +
" aaaaaa" + EOL +
" aaaaa";
StringBuffer sb = new StringBuffer();
new HelpFormatter().renderWrappedText(sb, width, padding, text);
assertEquals("multi-line padded text", expected, sb.toString());
}
@Test
public void testPrintOptions() throws Exception
{
StringBuffer sb = new StringBuffer();
HelpFormatter hf = new HelpFormatter();
final int leftPad = 1;
final int descPad = 3;
final String lpad = hf.createPadding(leftPad);
final String dpad = hf.createPadding(descPad);
Options options = null;
String expected = null;
options = new Options().addOption("a", false, "aaaa aaaa aaaa aaaa aaaa");
expected = lpad + "-a" + dpad + "aaaa aaaa aaaa aaaa aaaa";
hf.renderOptions(sb, 60, options, leftPad, descPad);
assertEquals("simple non-wrapped option", expected, sb.toString());
int nextLineTabStop = leftPad + descPad + "-a".length();
expected = lpad + "-a" + dpad + "aaaa aaaa aaaa" + EOL +
hf.createPadding(nextLineTabStop) + "aaaa aaaa";
sb.setLength(0);
hf.renderOptions(sb, nextLineTabStop + 17, options, leftPad, descPad);
assertEquals("simple wrapped option", expected, sb.toString());
options = new Options().addOption("a", "aaa", false, "dddd dddd dddd dddd");
expected = lpad + "-a,--aaa" + dpad + "dddd dddd dddd dddd";
sb.setLength(0);
hf.renderOptions(sb, 60, options, leftPad, descPad);
assertEquals("long non-wrapped option", expected, sb.toString());
nextLineTabStop = leftPad + descPad + "-a,--aaa".length();
expected = lpad + "-a,--aaa" + dpad + "dddd dddd" + EOL +
hf.createPadding(nextLineTabStop) + "dddd dddd";
sb.setLength(0);
hf.renderOptions(sb, 25, options, leftPad, descPad);
assertEquals("long wrapped option", expected, sb.toString());
options = new Options().
addOption("a", "aaa", false, "dddd dddd dddd dddd").
addOption("b", false, "feeee eeee eeee eeee");
expected = lpad + "-a,--aaa" + dpad + "dddd dddd" + EOL +
hf.createPadding(nextLineTabStop) + "dddd dddd" + EOL +
lpad + "-b " + dpad + "feeee eeee" + EOL +
hf.createPadding(nextLineTabStop) + "eeee eeee";
sb.setLength(0);
hf.renderOptions(sb, 25, options, leftPad, descPad);
assertEquals("multiple wrapped options", expected, sb.toString());
}
@Test
public void testPrintHelpWithEmptySyntax()
{
HelpFormatter formatter = new HelpFormatter();
try
{
formatter.printHelp(null, new Options());
fail("null command line syntax should be rejected");
}
catch (IllegalArgumentException e)
{
// expected
}
try
{
formatter.printHelp("", new Options());
fail("empty command line syntax should be rejected");
}
catch (IllegalArgumentException e)
{
// expected
}
}
@Test
public void testAutomaticUsage() throws Exception
{
HelpFormatter hf = new HelpFormatter();
Options options = null;
String expected = "usage: app [-a]";
ByteArrayOutputStream out = new ByteArrayOutputStream();
PrintWriter pw = new PrintWriter(out);
options = new Options().addOption("a", false, "aaaa aaaa aaaa aaaa aaaa");
hf.printUsage(pw, 60, "app", options);
pw.flush();
assertEquals("simple auto usage", expected, out.toString().trim());
out.reset();
expected = "usage: app [-a] [-b]";
options = new Options().addOption("a", false, "aaaa aaaa aaaa aaaa aaaa")
.addOption("b", false, "bbb");
hf.printUsage(pw, 60, "app", options);
pw.flush();
assertEquals("simple auto usage", expected, out.toString().trim());
out.reset();
}
// This test ensures the options are properly sorted
// See https://issues.apache.org/jira/browse/CLI-131
@Test
public void testPrintUsage()
{
Option optionA = new Option("a", "first");
Option optionB = new Option("b", "second");
Option optionC = new Option("c", "third");
Options opts = new Options();
opts.addOption(optionA);
opts.addOption(optionB);
opts.addOption(optionC);
HelpFormatter helpFormatter = new HelpFormatter();
ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
PrintWriter printWriter = new PrintWriter(bytesOut);
helpFormatter.printUsage(printWriter, 80, "app", opts);
printWriter.close();
assertEquals("usage: app [-a] [-b] [-c]" + EOL, bytesOut.toString());
}
// uses the test for CLI-131 to implement CLI-155
@Test
public void testPrintSortedUsage()
{
Options opts = new Options();
opts.addOption(new Option("a", "first"));
opts.addOption(new Option("b", "second"));
opts.addOption(new Option("c", "third"));
HelpFormatter helpFormatter = new HelpFormatter();
helpFormatter.setOptionComparator(new Comparator()
{
public int compare(Option opt1, Option opt2)
{
// reverses the functionality of the default comparator
return opt2.getKey().compareToIgnoreCase(opt1.getKey());
}
});
StringWriter out = new StringWriter();
helpFormatter.printUsage(new PrintWriter(out), 80, "app", opts);
assertEquals("usage: app [-c] [-b] [-a]" + EOL, out.toString());
}
@Test
public void testPrintSortedUsageWithNullComparator()
{
Options opts = new Options();
opts.addOption(new Option("c", "first"));
opts.addOption(new Option("b", "second"));
opts.addOption(new Option("a", "third"));
HelpFormatter helpFormatter = new HelpFormatter();
helpFormatter.setOptionComparator(null);
StringWriter out = new StringWriter();
helpFormatter.printUsage(new PrintWriter(out), 80, "app", opts);
assertEquals("usage: app [-c] [-b] [-a]" + EOL, out.toString());
}
@Test
public void testPrintOptionGroupUsage()
{
OptionGroup group = new OptionGroup();
group.addOption(Option.builder("a").build());
group.addOption(Option.builder("b").build());
group.addOption(Option.builder("c").build());
Options options = new Options();
options.addOptionGroup(group);
StringWriter out = new StringWriter();
HelpFormatter formatter = new HelpFormatter();
formatter.printUsage(new PrintWriter(out), 80, "app", options);
assertEquals("usage: app [-a | -b | -c]" + EOL, out.toString());
}
@Test
public void testPrintRequiredOptionGroupUsage()
{
OptionGroup group = new OptionGroup();
group.addOption(Option.builder("a").build());
group.addOption(Option.builder("b").build());
group.addOption(Option.builder("c").build());
group.setRequired(true);
Options options = new Options();
options.addOptionGroup(group);
StringWriter out = new StringWriter();
HelpFormatter formatter = new HelpFormatter();
formatter.printUsage(new PrintWriter(out), 80, "app", options);
assertEquals("usage: app -a | -b | -c" + EOL, out.toString());
}
@Test
public void testPrintOptionWithEmptyArgNameUsage()
{
Option option = new Option("f", true, null);
option.setArgName("");
option.setRequired(true);
Options options = new Options();
options.addOption(option);
StringWriter out = new StringWriter();
HelpFormatter formatter = new HelpFormatter();
formatter.printUsage(new PrintWriter(out), 80, "app", options);
assertEquals("usage: app -f" + EOL, out.toString());
}
@Test
public void testDefaultArgName()
{
Option option = Option.builder("f").hasArg().required(true).build();
Options options = new Options();
options.addOption(option);
StringWriter out = new StringWriter();
HelpFormatter formatter = new HelpFormatter();
formatter.setArgName("argument");
formatter.printUsage(new PrintWriter(out), 80, "app", options);
assertEquals("usage: app -f " + EOL, out.toString());
}
@Test
public void testRtrim()
{
HelpFormatter formatter = new HelpFormatter();
assertEquals(null, formatter.rtrim(null));
assertEquals("", formatter.rtrim(""));
assertEquals(" foo", formatter.rtrim(" foo "));
}
@Test
public void testAccessors()
{
HelpFormatter formatter = new HelpFormatter();
formatter.setArgName("argname");
assertEquals("arg name", "argname", formatter.getArgName());
formatter.setDescPadding(3);
assertEquals("desc padding", 3, formatter.getDescPadding());
formatter.setLeftPadding(7);
assertEquals("left padding", 7, formatter.getLeftPadding());
formatter.setLongOptPrefix("~~");
assertEquals("long opt prefix", "~~", formatter.getLongOptPrefix());
formatter.setNewLine("\n");
assertEquals("new line", "\n", formatter.getNewLine());
formatter.setOptPrefix("~");
assertEquals("opt prefix", "~", formatter.getOptPrefix());
formatter.setSyntaxPrefix("-> ");
assertEquals("syntax prefix", "-> ", formatter.getSyntaxPrefix());
formatter.setWidth(80);
assertEquals("width", 80, formatter.getWidth());
}
@Test
public void testHeaderStartingWithLineSeparator()
{
// related to Bugzilla #21215
Options options = new Options();
HelpFormatter formatter = new HelpFormatter();
String header = EOL + "Header";
String footer = "Footer";
StringWriter out = new StringWriter();
formatter.printHelp(new PrintWriter(out), 80, "foobar", header, options, 2, 2, footer, true);
assertEquals(
"usage: foobar" + EOL +
"" + EOL +
"Header" + EOL +
"" + EOL +
"Footer" + EOL
, out.toString());
}
@Test
public void testIndentedHeaderAndFooter()
{
// related to CLI-207
Options options = new Options();
HelpFormatter formatter = new HelpFormatter();
String header = " Header1\n Header2";
String footer = " Footer1\n Footer2";
StringWriter out = new StringWriter();
formatter.printHelp(new PrintWriter(out), 80, "foobar", header, options, 2, 2, footer, true);
assertEquals(
"usage: foobar" + EOL +
" Header1" + EOL +
" Header2" + EOL +
"" + EOL +
" Footer1" + EOL +
" Footer2" + EOL
, out.toString());
}
@Test
public void testOptionWithoutShortFormat()
{
// related to Bugzilla #19383 (CLI-67)
Options options = new Options();
options.addOption(new Option("a", "aaa", false, "aaaaaaa"));
options.addOption(new Option(null, "bbb", false, "bbbbbbb"));
options.addOption(new Option("c", null, false, "ccccccc"));
HelpFormatter formatter = new HelpFormatter();
StringWriter out = new StringWriter();
formatter.printHelp(new PrintWriter(out), 80, "foobar", "", options, 2, 2, "", true);
assertEquals(
"usage: foobar [-a] [--bbb] [-c]" + EOL +
" -a,--aaa aaaaaaa" + EOL +
" --bbb bbbbbbb" + EOL +
" -c ccccccc" + EOL
, out.toString());
}
@Test
public void testOptionWithoutShortFormat2()
{
// related to Bugzilla #27635 (CLI-26)
Option help = new Option("h", "help", false, "print this message");
Option version = new Option("v", "version", false, "print version information");
Option newRun = new Option("n", "new", false, "Create NLT cache entries only for new items");
Option trackerRun = new Option("t", "tracker", false, "Create NLT cache entries only for tracker items");
Option timeLimit = Option.builder("l")
.longOpt("limit")
.hasArg()
.valueSeparator()
.desc("Set time limit for execution, in mintues")
.build();
Option age = Option.builder("a").longOpt("age")
.hasArg()
.valueSeparator()
.desc("Age (in days) of cache item before being recomputed")
.build();
Option server = Option.builder("s").longOpt("server")
.hasArg()
.valueSeparator()
.desc("The NLT server address")
.build();
Option numResults = Option.builder("r").longOpt("results")
.hasArg()
.valueSeparator()
.desc("Number of results per item")
.build();
Option configFile = Option.builder().longOpt("config")
.hasArg()
.valueSeparator()
.desc("Use the specified configuration file")
.build();
Options mOptions = new Options();
mOptions.addOption(help);
mOptions.addOption(version);
mOptions.addOption(newRun);
mOptions.addOption(trackerRun);
mOptions.addOption(timeLimit);
mOptions.addOption(age);
mOptions.addOption(server);
mOptions.addOption(numResults);
mOptions.addOption(configFile);
HelpFormatter formatter = new HelpFormatter();
final String EOL = System.getProperty("line.separator");
StringWriter out = new StringWriter();
formatter.printHelp(new PrintWriter(out),80,"commandline","header",mOptions,2,2,"footer",true);
assertEquals(
"usage: commandline [-a ] [--config ] [-h] [-l ] [-n] [-r ]" + EOL +
" [-s ] [-t] [-v]" + EOL +
"header"+EOL+
" -a,--age Age (in days) of cache item before being recomputed"+EOL+
" --config Use the specified configuration file"+EOL+
" -h,--help print this message"+EOL+
" -l,--limit Set time limit for execution, in mintues"+EOL+
" -n,--new Create NLT cache entries only for new items"+EOL+
" -r,--results Number of results per item"+EOL+
" -s,--server The NLT server address"+EOL+
" -t,--tracker Create NLT cache entries only for tracker items"+EOL+
" -v,--version print version information"+EOL+
"footer"+EOL
,out.toString());
}
@Test
public void testHelpWithLongOptSeparator() throws Exception
{
Options options = new Options();
options.addOption( "f", true, "the file" );
options.addOption(Option.builder("s").longOpt("size").desc("the size").hasArg().argName("SIZE").build());
options.addOption(Option.builder().longOpt("age").desc("the age").hasArg().build());
HelpFormatter formatter = new HelpFormatter();
assertEquals(HelpFormatter.DEFAULT_LONG_OPT_SEPARATOR, formatter.getLongOptSeparator());
formatter.setLongOptSeparator("=");
assertEquals("=", formatter.getLongOptSeparator());
StringWriter out = new StringWriter();
formatter.printHelp(new PrintWriter(out), 80, "create", "header", options, 2, 2, "footer");
assertEquals(
"usage: create" + EOL +
"header" + EOL +
" --age= the age" + EOL +
" -f the file" + EOL +
" -s,--size= the size" + EOL +
"footer" + EOL,
out.toString());
}
@Test
public void testUsageWithLongOptSeparator() throws Exception
{
Options options = new Options();
options.addOption( "f", true, "the file" );
options.addOption(Option.builder("s").longOpt("size").desc("the size").hasArg().argName("SIZE").build());
options.addOption(Option.builder().longOpt("age").desc("the age").hasArg().build());
HelpFormatter formatter = new HelpFormatter();
formatter.setLongOptSeparator("=");
StringWriter out = new StringWriter();
formatter.printUsage(new PrintWriter(out), 80, "create", options);
assertEquals("usage: create [--age=] [-f ] [-s ]", out.toString().trim());
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/OptionBuilderTest.java 0100644 0000765 0000024 00000015311 12537250704 030367 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import org.junit.Test;
@SuppressWarnings("deprecation") // OptionBuilder is marked deprecated
public class OptionBuilderTest
{
@Test
public void testCompleteOption( ) {
Option simple = OptionBuilder.withLongOpt( "simple option")
.hasArg( )
.isRequired( )
.hasArgs( )
.withType( Float.class )
.withDescription( "this is a simple option" )
.create( 's' );
assertEquals( "s", simple.getOpt() );
assertEquals( "simple option", simple.getLongOpt() );
assertEquals( "this is a simple option", simple.getDescription() );
assertEquals( simple.getType(), Float.class );
assertTrue( simple.hasArg() );
assertTrue( simple.isRequired() );
assertTrue( simple.hasArgs() );
}
@Test
public void testTwoCompleteOptions( ) {
Option simple = OptionBuilder.withLongOpt( "simple option")
.hasArg( )
.isRequired( )
.hasArgs( )
.withType( Float.class )
.withDescription( "this is a simple option" )
.create( 's' );
assertEquals( "s", simple.getOpt() );
assertEquals( "simple option", simple.getLongOpt() );
assertEquals( "this is a simple option", simple.getDescription() );
assertEquals( simple.getType(), Float.class );
assertTrue( simple.hasArg() );
assertTrue( simple.isRequired() );
assertTrue( simple.hasArgs() );
simple = OptionBuilder.withLongOpt( "dimple option")
.hasArg( )
.withDescription( "this is a dimple option" )
.create( 'd' );
assertEquals( "d", simple.getOpt() );
assertEquals( "dimple option", simple.getLongOpt() );
assertEquals( "this is a dimple option", simple.getDescription() );
assertEquals( String.class, simple.getType() );
assertTrue( simple.hasArg() );
assertTrue( !simple.isRequired() );
assertTrue( !simple.hasArgs() );
}
@Test
public void testBaseOptionCharOpt() {
Option base = OptionBuilder.withDescription( "option description")
.create( 'o' );
assertEquals( "o", base.getOpt() );
assertEquals( "option description", base.getDescription() );
assertTrue( !base.hasArg() );
}
@Test
public void testBaseOptionStringOpt() {
Option base = OptionBuilder.withDescription( "option description")
.create( "o" );
assertEquals( "o", base.getOpt() );
assertEquals( "option description", base.getDescription() );
assertTrue( !base.hasArg() );
}
@Test
public void testSpecialOptChars() throws Exception
{
// '?'
Option opt1 = OptionBuilder.withDescription("help options").create('?');
assertEquals("?", opt1.getOpt());
// '@'
Option opt2 = OptionBuilder.withDescription("read from stdin").create('@');
assertEquals("@", opt2.getOpt());
// ' '
try {
OptionBuilder.create(' ');
fail( "IllegalArgumentException not caught" );
} catch (IllegalArgumentException e) {
// success
}
}
@Test
public void testOptionArgNumbers()
{
Option opt = OptionBuilder.withDescription( "option description" )
.hasArgs( 2 )
.create( 'o' );
assertEquals( 2, opt.getArgs() );
}
@Test
public void testIllegalOptions() {
// bad single character option
try {
OptionBuilder.withDescription( "option description" ).create( '"' );
fail( "IllegalArgumentException not caught" );
}
catch( IllegalArgumentException exp ) {
// success
}
// bad character in option string
try {
OptionBuilder.create( "opt`" );
fail( "IllegalArgumentException not caught" );
}
catch( IllegalArgumentException exp ) {
// success
}
// valid option
try {
OptionBuilder.create( "opt" );
// success
}
catch( IllegalArgumentException exp ) {
fail( "IllegalArgumentException caught" );
}
}
@Test
public void testCreateIncompleteOption() {
try
{
OptionBuilder.hasArg().create();
fail("Incomplete option should be rejected");
}
catch (IllegalArgumentException e)
{
// expected
// implicitly reset the builder
OptionBuilder.create( "opt" );
}
}
@Test
public void testBuilderIsResettedAlways() {
try
{
OptionBuilder.withDescription("JUnit").create('"');
fail("IllegalArgumentException expected");
}
catch (IllegalArgumentException e)
{
// expected
}
assertNull("we inherited a description", OptionBuilder.create('x').getDescription());
try
{
OptionBuilder.withDescription("JUnit").create();
fail("IllegalArgumentException expected");
}
catch (IllegalArgumentException e)
{
// expected
}
assertNull("we inherited a description", OptionBuilder.create('x').getDescription());
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/OptionGroupTest.java 0100644 0000765 0000024 00000022557 12537250704 030107 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.Properties;
import org.junit.Before;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class OptionGroupTest
{
private Options _options = null;
private final Parser parser = new PosixParser();
@Before
public void setUp()
{
Option file = new Option( "f", "file", false, "file to process" );
Option dir = new Option( "d", "directory", false, "directory to process" );
OptionGroup group = new OptionGroup();
group.addOption( file );
group.addOption( dir );
_options = new Options().addOptionGroup( group );
Option section = new Option( "s", "section", false, "section to process" );
Option chapter = new Option( "c", "chapter", false, "chapter to process" );
OptionGroup group2 = new OptionGroup();
group2.addOption( section );
group2.addOption( chapter );
_options.addOptionGroup( group2 );
Option importOpt = new Option( null, "import", false, "section to process" );
Option exportOpt = new Option( null, "export", false, "chapter to process" );
OptionGroup group3 = new OptionGroup();
group3.addOption( importOpt );
group3.addOption( exportOpt );
_options.addOptionGroup( group3 );
_options.addOption( "r", "revision", false, "revision number" );
}
@Test
public void testSingleOptionFromGroup() throws Exception
{
String[] args = new String[] { "-f" };
CommandLine cl = parser.parse( _options, args);
assertTrue( "Confirm -r is NOT set", !cl.hasOption("r") );
assertTrue( "Confirm -f is set", cl.hasOption("f") );
assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
}
@Test
public void testSingleOption() throws Exception
{
String[] args = new String[] { "-r" };
CommandLine cl = parser.parse( _options, args);
assertTrue( "Confirm -r is set", cl.hasOption("r") );
assertTrue( "Confirm -f is NOT set", !cl.hasOption("f") );
assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
}
@Test
public void testTwoValidOptions() throws Exception
{
String[] args = new String[] { "-r", "-f" };
CommandLine cl = parser.parse( _options, args);
assertTrue( "Confirm -r is set", cl.hasOption("r") );
assertTrue( "Confirm -f is set", cl.hasOption("f") );
assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
}
@Test
public void testSingleLongOption() throws Exception
{
String[] args = new String[] { "--file" };
CommandLine cl = parser.parse( _options, args);
assertTrue( "Confirm -r is NOT set", !cl.hasOption("r") );
assertTrue( "Confirm -f is set", cl.hasOption("f") );
assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
}
@Test
public void testTwoValidLongOptions() throws Exception
{
String[] args = new String[] { "--revision", "--file" };
CommandLine cl = parser.parse( _options, args);
assertTrue( "Confirm -r is set", cl.hasOption("r") );
assertTrue( "Confirm -f is set", cl.hasOption("f") );
assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
}
@Test
public void testNoOptionsExtraArgs() throws Exception
{
String[] args = new String[] { "arg1", "arg2" };
CommandLine cl = parser.parse( _options, args);
assertTrue( "Confirm -r is NOT set", !cl.hasOption("r") );
assertTrue( "Confirm -f is NOT set", !cl.hasOption("f") );
assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
assertTrue( "Confirm TWO extra args", cl.getArgList().size() == 2);
}
@Test
public void testTwoOptionsFromGroup() throws Exception
{
String[] args = new String[] { "-f", "-d" };
try
{
parser.parse( _options, args);
fail( "two arguments from group not allowed" );
}
catch (AlreadySelectedException e)
{
assertNotNull("null option group", e.getOptionGroup());
assertEquals("selected option", "f", e.getOptionGroup().getSelected());
assertEquals("option", "d", e.getOption().getOpt());
}
}
@Test
public void testTwoLongOptionsFromGroup() throws Exception
{
String[] args = new String[] { "--file", "--directory" };
try
{
parser.parse(_options, args);
fail( "two arguments from group not allowed" );
}
catch (AlreadySelectedException e)
{
assertNotNull("null option group", e.getOptionGroup());
assertEquals("selected option", "f", e.getOptionGroup().getSelected());
assertEquals("option", "d", e.getOption().getOpt());
}
}
@Test
public void testTwoOptionsFromDifferentGroup() throws Exception
{
String[] args = new String[] { "-f", "-s" };
CommandLine cl = parser.parse( _options, args);
assertTrue( "Confirm -r is NOT set", !cl.hasOption("r") );
assertTrue( "Confirm -f is set", cl.hasOption("f") );
assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
assertTrue( "Confirm -s is set", cl.hasOption("s") );
assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
assertTrue( "Confirm NO extra args", cl.getArgList().size() == 0);
}
@Test
public void testTwoOptionsFromGroupWithProperties() throws Exception
{
String[] args = new String[] { "-f" };
Properties properties = new Properties();
properties.put("d", "true");
CommandLine cl = parser.parse( _options, args, properties);
assertTrue(cl.hasOption("f"));
assertTrue(!cl.hasOption("d"));
}
@Test
public void testValidLongOnlyOptions() throws Exception
{
CommandLine cl1 = parser.parse(_options, new String[]{"--export"});
assertTrue("Confirm --export is set", cl1.hasOption("export"));
CommandLine cl2 = parser.parse(_options, new String[]{"--import"});
assertTrue("Confirm --import is set", cl2.hasOption("import"));
}
@Test
public void testToString()
{
OptionGroup group1 = new OptionGroup();
group1.addOption(new Option(null, "foo", false, "Foo"));
group1.addOption(new Option(null, "bar", false, "Bar"));
if (!"[--bar Bar, --foo Foo]".equals(group1.toString())) {
assertEquals("[--foo Foo, --bar Bar]", group1.toString());
}
OptionGroup group2 = new OptionGroup();
group2.addOption(new Option("f", "foo", false, "Foo"));
group2.addOption(new Option("b", "bar", false, "Bar"));
if (!"[-b Bar, -f Foo]".equals(group2.toString())) {
assertEquals("[-f Foo, -b Bar]", group2.toString());
}
}
@Test
public void testGetNames()
{
OptionGroup group = new OptionGroup();
group.addOption(OptionBuilder.create('a'));
group.addOption(OptionBuilder.create('b'));
assertNotNull("null names", group.getNames());
assertEquals(2, group.getNames().size());
assertTrue(group.getNames().contains("a"));
assertTrue(group.getNames().contains("b"));
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/OptionsTest.java 0100644 0000765 0000024 00000014055 12537250704 027247 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class OptionsTest
{
@Test
public void testSimple()
{
Options opts = new Options();
opts.addOption("a", false, "toggle -a");
opts.addOption("b", true, "toggle -b");
assertTrue(opts.hasOption("a"));
assertTrue(opts.hasOption("b"));
}
@Test
public void testDuplicateSimple()
{
Options opts = new Options();
opts.addOption("a", false, "toggle -a");
opts.addOption("a", true, "toggle -a*");
assertEquals("last one in wins", "toggle -a*", opts.getOption("a").getDescription());
}
@Test
public void testLong()
{
Options opts = new Options();
opts.addOption("a", "--a", false, "toggle -a");
opts.addOption("b", "--b", true, "set -b");
assertTrue(opts.hasOption("a"));
assertTrue(opts.hasOption("b"));
}
@Test
public void testDuplicateLong()
{
Options opts = new Options();
opts.addOption("a", "--a", false, "toggle -a");
opts.addOption("a", "--a", false, "toggle -a*");
assertEquals("last one in wins", "toggle -a*", opts.getOption("a").getDescription());
}
@Test
public void testHelpOptions()
{
Option longOnly1 = OptionBuilder.withLongOpt("long-only1").create();
Option longOnly2 = OptionBuilder.withLongOpt("long-only2").create();
Option shortOnly1 = OptionBuilder.create("1");
Option shortOnly2 = OptionBuilder.create("2");
Option bothA = OptionBuilder.withLongOpt("bothA").create("a");
Option bothB = OptionBuilder.withLongOpt("bothB").create("b");
Options options = new Options();
options.addOption(longOnly1);
options.addOption(longOnly2);
options.addOption(shortOnly1);
options.addOption(shortOnly2);
options.addOption(bothA);
options.addOption(bothB);
Collection allOptions = new ArrayList ();
allOptions.add(longOnly1);
allOptions.add(longOnly2);
allOptions.add(shortOnly1);
allOptions.add(shortOnly2);
allOptions.add(bothA);
allOptions.add(bothB);
Collection helpOptions = options.helpOptions();
assertTrue("Everything in all should be in help", helpOptions.containsAll(allOptions));
assertTrue("Everything in help should be in all", allOptions.containsAll(helpOptions));
}
@Test
public void testMissingOptionException() throws ParseException
{
Options options = new Options();
options.addOption(OptionBuilder.isRequired().create("f"));
try
{
new PosixParser().parse(options, new String[0]);
fail("Expected MissingOptionException to be thrown");
}
catch (MissingOptionException e)
{
assertEquals("Missing required option: f", e.getMessage());
}
}
@Test
public void testMissingOptionsException() throws ParseException
{
Options options = new Options();
options.addOption(OptionBuilder.isRequired().create("f"));
options.addOption(OptionBuilder.isRequired().create("x"));
try
{
new PosixParser().parse(options, new String[0]);
fail("Expected MissingOptionException to be thrown");
}
catch (MissingOptionException e)
{
assertEquals("Missing required options: f, x", e.getMessage());
}
}
@Test
public void testToString()
{
Options options = new Options();
options.addOption("f", "foo", true, "Foo");
options.addOption("b", "bar", false, "Bar");
String s = options.toString();
assertNotNull("null string returned", s);
assertTrue("foo option missing", s.toLowerCase().contains("foo"));
assertTrue("bar option missing", s.toLowerCase().contains("bar"));
}
@Test
public void testGetOptionsGroups()
{
Options options = new Options();
OptionGroup group1 = new OptionGroup();
group1.addOption(OptionBuilder.create('a'));
group1.addOption(OptionBuilder.create('b'));
OptionGroup group2 = new OptionGroup();
group2.addOption(OptionBuilder.create('x'));
group2.addOption(OptionBuilder.create('y'));
options.addOptionGroup(group1);
options.addOptionGroup(group2);
assertNotNull(options.getOptionGroups());
assertEquals(2, options.getOptionGroups().size());
}
@Test
public void testGetMatchingOpts()
{
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("version").create());
options.addOption(OptionBuilder.withLongOpt("verbose").create());
assertTrue(options.getMatchingOptions("foo").isEmpty());
assertEquals(1, options.getMatchingOptions("version").size());
assertEquals(2, options.getMatchingOptions("ver").size());
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/OptionTest.java 0100644 0000765 0000024 00000020004 12537250704 027053 0 ustar 00bene staff 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
public class OptionTest
{
private static class TestOption extends Option
{
private static final long serialVersionUID = 1L;
public TestOption(String opt, boolean hasArg, String description) throws IllegalArgumentException
{
super(opt, hasArg, description);
}
@Override
public boolean addValue(String value)
{
addValueForProcessing(value);
return true;
}
}
@Test
public void testClear()
{
TestOption option = new TestOption("x", true, "");
assertEquals(0, option.getValuesList().size());
option.addValue("a");
assertEquals(1, option.getValuesList().size());
option.clearValues();
assertEquals(0, option.getValuesList().size());
}
// See http://issues.apache.org/jira/browse/CLI-21
@Test
public void testClone()
{
TestOption a = new TestOption("a", true, "");
TestOption b = (TestOption) a.clone();
assertEquals(a, b);
assertNotSame(a, b);
a.setDescription("a");
assertEquals("", b.getDescription());
b.setArgs(2);
b.addValue("b1");
b.addValue("b2");
assertEquals(1, a.getArgs());
assertEquals(0, a.getValuesList().size());
assertEquals(2, b.getValues().length);
}
private static class DefaultOption extends Option
{
private static final long serialVersionUID = 1L;
private final String defaultValue;
public DefaultOption(String opt, String description, String defaultValue) throws IllegalArgumentException
{
super(opt, true, description);
this.defaultValue = defaultValue;
}
@Override
public String getValue()
{
return super.getValue() != null ? super.getValue() : defaultValue;
}
}
@Test
public void testSubclass()
{
Option option = new DefaultOption("f", "file", "myfile.txt");
Option clone = (Option) option.clone();
assertEquals("myfile.txt", clone.getValue());
assertEquals(DefaultOption.class, clone.getClass());
}
@Test
public void testHasArgName()
{
Option option = new Option("f", null);
option.setArgName(null);
assertFalse(option.hasArgName());
option.setArgName("");
assertFalse(option.hasArgName());
option.setArgName("file");
assertTrue(option.hasArgName());
}
@Test
public void testHasArgs()
{
Option option = new Option("f", null);
option.setArgs(0);
assertFalse(option.hasArgs());
option.setArgs(1);
assertFalse(option.hasArgs());
option.setArgs(10);
assertTrue(option.hasArgs());
option.setArgs(Option.UNLIMITED_VALUES);
assertTrue(option.hasArgs());
option.setArgs(Option.UNINITIALIZED);
assertFalse(option.hasArgs());
}
@Test
public void testGetValue()
{
Option option = new Option("f", null);
option.setArgs(Option.UNLIMITED_VALUES);
assertEquals("default", option.getValue("default"));
assertEquals(null, option.getValue(0));
option.addValueForProcessing("foo");
assertEquals("foo", option.getValue());
assertEquals("foo", option.getValue(0));
assertEquals("foo", option.getValue("default"));
}
@Test
public void testBuilderMethods()
{
char defaultSeparator = (char) 0;
checkOption(Option.builder("a").desc("desc").build(),
"a", "desc", null, Option.UNINITIALIZED, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").build(),
"a", "desc", null, Option.UNINITIALIZED, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").longOpt("aaa").build(),
"a", "desc", "aaa", Option.UNINITIALIZED, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").hasArg(true).build(),
"a", "desc", null, 1, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").hasArg(false).build(),
"a", "desc", null, Option.UNINITIALIZED, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").hasArg(true).build(),
"a", "desc", null, 1, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").numberOfArgs(3).build(),
"a", "desc", null, 3, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").required(true).build(),
"a", "desc", null, Option.UNINITIALIZED, null, true, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").required(false).build(),
"a", "desc", null, Option.UNINITIALIZED, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").argName("arg1").build(),
"a", "desc", null, Option.UNINITIALIZED, "arg1", false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").optionalArg(false).build(),
"a", "desc", null, Option.UNINITIALIZED, null, false, false, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").optionalArg(true).build(),
"a", "desc", null, Option.UNINITIALIZED, null, false, true, defaultSeparator, String.class);
checkOption(Option.builder("a").desc("desc").valueSeparator(':').build(),
"a", "desc", null, Option.UNINITIALIZED, null, false, false, ':', String.class);
checkOption(Option.builder("a").desc("desc").type(Integer.class).build(),
"a", "desc", null, Option.UNINITIALIZED, null, false, false, defaultSeparator, Integer.class);
}
@Test(expected=IllegalArgumentException.class)
public void testBuilderInsufficientParams1()
{
Option.builder().desc("desc").build();
}
@Test(expected=IllegalArgumentException.class)
public void testBuilderInsufficientParams2()
{
Option.builder(null).desc("desc").build();
}
private static void checkOption(Option option, String opt, String description, String longOpt, int numArgs,
String argName, boolean required, boolean optionalArg,
char valueSeparator, Class cls)
{
assertEquals(opt, option.getOpt());
assertEquals(description, option.getDescription());
assertEquals(longOpt, option.getLongOpt());
assertEquals(numArgs, option.getArgs());
assertEquals(argName, option.getArgName());
assertEquals(required, option.isRequired());
assertEquals(optionalArg, option.hasOptionalArg());
assertEquals(valueSeparator, option.getValueSeparator());
assertEquals(cls, option.getType());
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/ParserTestCase.java 0100644 0000765 0000024 00000111406 12537250704 027642 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import org.junit.Before;
import org.junit.Test;
/**
* Abstract test case testing common parser features.
*/
public abstract class ParserTestCase
{
protected CommandLineParser parser;
protected Options options;
@Before
public void setUp()
{
options = new Options()
.addOption("a", "enable-a", false, "turn [a] on or off")
.addOption("b", "bfile", true, "set the value of [b]")
.addOption("c", "copt", false, "turn [c] on or off");
}
@Test
public void testSimpleShort() throws Exception
{
String[] args = new String[] { "-a",
"-b", "toast",
"foo", "bar" };
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm -a is set", cl.hasOption("a"));
assertTrue("Confirm -b is set", cl.hasOption("b"));
assertTrue("Confirm arg of -b", cl.getOptionValue("b").equals("toast"));
assertTrue("Confirm size of extra args", cl.getArgList().size() == 2);
}
@Test
public void testSimpleLong() throws Exception
{
String[] args = new String[] { "--enable-a",
"--bfile", "toast",
"foo", "bar" };
CommandLine cl = parser.parse(options, args);
assertTrue( "Confirm -a is set", cl.hasOption("a") );
assertTrue( "Confirm -b is set", cl.hasOption("b") );
assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
assertTrue( "Confirm arg of --bfile", cl.getOptionValue( "bfile" ).equals( "toast" ) );
assertTrue( "Confirm size of extra args", cl.getArgList().size() == 2);
}
@Test
public void testMultiple() throws Exception
{
String[] args = new String[] { "-c",
"foobar",
"-b", "toast" };
CommandLine cl = parser.parse(options, args, true);
assertTrue("Confirm -c is set", cl.hasOption("c"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
cl = parser.parse(options, cl.getArgs());
assertTrue("Confirm -c is not set", !cl.hasOption("c"));
assertTrue("Confirm -b is set", cl.hasOption("b"));
assertTrue("Confirm arg of -b", cl.getOptionValue("b").equals("toast"));
assertTrue("Confirm 1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
assertTrue("Confirm value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("foobar"));
}
@Test
public void testMultipleWithLong() throws Exception
{
String[] args = new String[] { "--copt",
"foobar",
"--bfile", "toast" };
CommandLine cl = parser.parse(options, args, true);
assertTrue("Confirm -c is set", cl.hasOption("c"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
cl = parser.parse(options, cl.getArgs());
assertTrue("Confirm -c is not set", !cl.hasOption("c"));
assertTrue("Confirm -b is set", cl.hasOption("b"));
assertTrue("Confirm arg of -b", cl.getOptionValue("b").equals("toast"));
assertTrue("Confirm 1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
assertTrue("Confirm value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("foobar"));
}
@Test
public void testUnrecognizedOption() throws Exception
{
String[] args = new String[] { "-a", "-d", "-b", "toast", "foo", "bar" };
try
{
parser.parse(options, args);
fail("UnrecognizedOptionException wasn't thrown");
}
catch (UnrecognizedOptionException e)
{
assertEquals("-d", e.getOption());
}
}
@Test
public void testMissingArg() throws Exception
{
String[] args = new String[] { "-b" };
boolean caught = false;
try
{
parser.parse(options, args);
}
catch (MissingArgumentException e)
{
caught = true;
assertEquals("option missing an argument", "b", e.getOption().getOpt());
}
assertTrue( "Confirm MissingArgumentException caught", caught );
}
@Test
public void testDoubleDash1() throws Exception
{
String[] args = new String[] { "--copt",
"--",
"-b", "toast" };
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm -c is set", cl.hasOption("c"));
assertTrue("Confirm -b is not set", !cl.hasOption("b"));
assertTrue("Confirm 2 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 2);
}
@Test
public void testDoubleDash2() throws Exception
{
Options options = new Options();
options.addOption(OptionBuilder.hasArg().create('n'));
options.addOption(OptionBuilder.create('m'));
try
{
parser.parse(options, new String[]{"-n", "--", "-m"});
fail("MissingArgumentException not thrown for option -n");
}
catch (MissingArgumentException e)
{
assertNotNull("option null", e.getOption());
assertEquals("n", e.getOption().getOpt());
}
}
@Test
public void testSingleDash() throws Exception
{
String[] args = new String[] { "--copt",
"-b", "-",
"-a",
"-" };
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm -a is set", cl.hasOption("a"));
assertTrue("Confirm -b is set", cl.hasOption("b"));
assertTrue("Confirm arg of -b", cl.getOptionValue("b").equals("-"));
assertTrue("Confirm 1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
assertTrue("Confirm value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("-"));
}
@Test
public void testStopAtUnexpectedArg() throws Exception
{
String[] args = new String[] { "-c",
"foober",
"-b",
"toast" };
CommandLine cl = parser.parse(options, args, true);
assertTrue("Confirm -c is set", cl.hasOption("c"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
}
@Test
public void testStopAtExpectedArg() throws Exception
{
String[] args = new String[]{"-b", "foo"};
CommandLine cl = parser.parse(options, args, true);
assertTrue("Confirm -b is set", cl.hasOption('b'));
assertEquals("Confirm -b is set", "foo", cl.getOptionValue('b'));
assertTrue("Confirm no extra args: " + cl.getArgList().size(), cl.getArgList().size() == 0);
}
@Test
public void testStopAtNonOptionShort() throws Exception
{
String[] args = new String[]{"-z",
"-a",
"-btoast"};
CommandLine cl = parser.parse(options, args, true);
assertFalse("Confirm -a is not set", cl.hasOption("a"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
}
@Test
public void testStopAtNonOptionLong() throws Exception
{
String[] args = new String[]{"--zop==1",
"-abtoast",
"--b=bar"};
CommandLine cl = parser.parse(options, args, true);
assertFalse("Confirm -a is not set", cl.hasOption("a"));
assertFalse("Confirm -b is not set", cl.hasOption("b"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
}
@Test
public void testNegativeArgument() throws Exception
{
String[] args = new String[] { "-b", "-1"} ;
CommandLine cl = parser.parse(options, args);
assertEquals("-1", cl.getOptionValue("b"));
}
@Test
public void testNegativeOption() throws Exception
{
String[] args = new String[] { "-b", "-1"} ;
options.addOption("1", false, null);
CommandLine cl = parser.parse(options, args);
assertEquals("-1", cl.getOptionValue("b"));
}
@Test
public void testArgumentStartingWithHyphen() throws Exception
{
String[] args = new String[]{"-b", "-foo"};
CommandLine cl = parser.parse(options, args);
assertEquals("-foo", cl.getOptionValue("b"));
}
@Test
public void testShortWithEqual() throws Exception
{
String[] args = new String[] { "-f=bar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
CommandLine cl = parser.parse(options, args);
assertEquals("bar", cl.getOptionValue("foo"));
}
@Test
public void testShortWithoutEqual() throws Exception
{
String[] args = new String[] { "-fbar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
CommandLine cl = parser.parse(options, args);
assertEquals("bar", cl.getOptionValue("foo"));
}
@Test
public void testLongWithEqualDoubleDash() throws Exception
{
String[] args = new String[] { "--foo=bar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
CommandLine cl = parser.parse(options, args);
assertEquals("bar", cl.getOptionValue("foo"));
}
@Test
public void testLongWithEqualSingleDash() throws Exception
{
String[] args = new String[] { "-foo=bar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
CommandLine cl = parser.parse(options, args);
assertEquals("bar", cl.getOptionValue("foo"));
}
@Test
public void testLongWithoutEqualSingleDash() throws Exception
{
String[] args = new String[] { "-foobar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
CommandLine cl = parser.parse(options, args);
assertEquals("bar", cl.getOptionValue("foo"));
}
@Test
public void testAmbiguousLongWithoutEqualSingleDash() throws Exception
{
String[] args = new String[] { "-b", "-foobar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").hasOptionalArg().create('f'));
options.addOption(OptionBuilder.withLongOpt("bar").hasOptionalArg().create('b'));
CommandLine cl = parser.parse(options, args);
assertTrue(cl.hasOption("b"));
assertTrue(cl.hasOption("f"));
assertEquals("bar", cl.getOptionValue("foo"));
}
@Test
public void testLongWithoutEqualDoubleDash() throws Exception
{
String[] args = new String[] { "--foobar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
CommandLine cl = parser.parse(options, args, true);
assertFalse(cl.hasOption("foo")); // foo isn't expected to be recognized with a double dash
}
@Test
public void testLongWithUnexpectedArgument1() throws Exception
{
String[] args = new String[] { "--foo=bar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").create('f'));
try
{
parser.parse(options, args);
}
catch (UnrecognizedOptionException e)
{
assertEquals("--foo=bar", e.getOption());
return;
}
fail("UnrecognizedOptionException not thrown");
}
@Test
public void testLongWithUnexpectedArgument2() throws Exception
{
String[] args = new String[] { "-foobar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").create('f'));
try
{
parser.parse(options, args);
}
catch (UnrecognizedOptionException e)
{
assertEquals("-foobar", e.getOption());
return;
}
fail("UnrecognizedOptionException not thrown");
}
@Test
public void testShortWithUnexpectedArgument() throws Exception
{
String[] args = new String[] { "-f=bar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").create('f'));
try
{
parser.parse(options, args);
}
catch (UnrecognizedOptionException e)
{
assertEquals("-f=bar", e.getOption());
return;
}
fail("UnrecognizedOptionException not thrown");
}
@Test
public void testPropertiesOption1() throws Exception
{
String[] args = new String[] { "-Jsource=1.5", "-J", "target", "1.5", "foo" };
Options options = new Options();
options.addOption(OptionBuilder.withValueSeparator().hasArgs(2).create('J'));
CommandLine cl = parser.parse(options, args);
List values = Arrays.asList(cl.getOptionValues("J"));
assertNotNull("null values", values);
assertEquals("number of values", 4, values.size());
assertEquals("value 1", "source", values.get(0));
assertEquals("value 2", "1.5", values.get(1));
assertEquals("value 3", "target", values.get(2));
assertEquals("value 4", "1.5", values.get(3));
List argsleft = cl.getArgList();
assertEquals("Should be 1 arg left", 1, argsleft.size());
assertEquals("Expecting foo", "foo", argsleft.get(0));
}
@Test
public void testPropertiesOption2() throws Exception
{
String[] args = new String[] { "-Dparam1", "-Dparam2=value2", "-D"};
Options options = new Options();
options.addOption(OptionBuilder.withValueSeparator().hasOptionalArgs(2).create('D'));
CommandLine cl = parser.parse(options, args);
Properties props = cl.getOptionProperties("D");
assertNotNull("null properties", props);
assertEquals("number of properties in " + props, 2, props.size());
assertEquals("property 1", "true", props.getProperty("param1"));
assertEquals("property 2", "value2", props.getProperty("param2"));
List argsleft = cl.getArgList();
assertEquals("Should be no arg left", 0, argsleft.size());
}
@Test
public void testUnambiguousPartialLongOption1() throws Exception
{
String[] args = new String[] { "--ver" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("version").create());
options.addOption(OptionBuilder.withLongOpt("help").create());
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm --version is set", cl.hasOption("version"));
}
@Test
public void testUnambiguousPartialLongOption2() throws Exception
{
String[] args = new String[] { "-ver" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("version").create());
options.addOption(OptionBuilder.withLongOpt("help").create());
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm --version is set", cl.hasOption("version"));
}
@Test
public void testUnambiguousPartialLongOption3() throws Exception
{
String[] args = new String[] { "--ver=1" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("verbose").hasOptionalArg().create());
options.addOption(OptionBuilder.withLongOpt("help").create());
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm --verbose is set", cl.hasOption("verbose"));
assertEquals("1", cl.getOptionValue("verbose"));
}
@Test
public void testUnambiguousPartialLongOption4() throws Exception
{
String[] args = new String[] { "-ver=1" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("verbose").hasOptionalArg().create());
options.addOption(OptionBuilder.withLongOpt("help").create());
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm --verbose is set", cl.hasOption("verbose"));
assertEquals("1", cl.getOptionValue("verbose"));
}
@Test
public void testAmbiguousPartialLongOption1() throws Exception
{
String[] args = new String[] { "--ver" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("version").create());
options.addOption(OptionBuilder.withLongOpt("verbose").create());
boolean caught = false;
try
{
parser.parse(options, args);
}
catch (AmbiguousOptionException e)
{
caught = true;
assertEquals("Partial option", "--ver", e.getOption());
assertNotNull("Matching options null", e.getMatchingOptions());
assertEquals("Matching options size", 2, e.getMatchingOptions().size());
}
assertTrue( "Confirm MissingArgumentException caught", caught );
}
@Test
public void testAmbiguousPartialLongOption2() throws Exception
{
String[] args = new String[] { "-ver" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("version").create());
options.addOption(OptionBuilder.withLongOpt("verbose").create());
boolean caught = false;
try
{
parser.parse(options, args);
}
catch (AmbiguousOptionException e)
{
caught = true;
assertEquals("Partial option", "-ver", e.getOption());
assertNotNull("Matching options null", e.getMatchingOptions());
assertEquals("Matching options size", 2, e.getMatchingOptions().size());
}
assertTrue( "Confirm MissingArgumentException caught", caught );
}
@Test
public void testAmbiguousPartialLongOption3() throws Exception
{
String[] args = new String[] { "--ver=1" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("version").create());
options.addOption(OptionBuilder.withLongOpt("verbose").hasOptionalArg().create());
boolean caught = false;
try
{
parser.parse(options, args);
}
catch (AmbiguousOptionException e)
{
caught = true;
assertEquals("Partial option", "--ver", e.getOption());
assertNotNull("Matching options null", e.getMatchingOptions());
assertEquals("Matching options size", 2, e.getMatchingOptions().size());
}
assertTrue( "Confirm MissingArgumentException caught", caught );
}
@Test
public void testAmbiguousPartialLongOption4() throws Exception
{
String[] args = new String[] { "-ver=1" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("version").create());
options.addOption(OptionBuilder.withLongOpt("verbose").hasOptionalArg().create());
boolean caught = false;
try
{
parser.parse(options, args);
}
catch (AmbiguousOptionException e)
{
caught = true;
assertEquals("Partial option", "-ver", e.getOption());
assertNotNull("Matching options null", e.getMatchingOptions());
assertEquals("Matching options size", 2, e.getMatchingOptions().size());
}
assertTrue( "Confirm MissingArgumentException caught", caught );
}
@Test
public void testPartialLongOptionSingleDash() throws Exception
{
String[] args = new String[] { "-ver" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("version").create());
options.addOption(OptionBuilder.hasArg().create('v'));
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm --version is set", cl.hasOption("version"));
assertTrue("Confirm -v is not set", !cl.hasOption("v"));
}
@Test
public void testWithRequiredOption() throws Exception
{
String[] args = new String[] { "-b", "file" };
Options options = new Options();
options.addOption("a", "enable-a", false, null);
options.addOption(OptionBuilder.withLongOpt("bfile").hasArg().isRequired().create('b'));
CommandLine cl = parser.parse(options,args);
assertTrue("Confirm -a is NOT set", !cl.hasOption("a"));
assertTrue("Confirm -b is set", cl.hasOption("b"));
assertTrue("Confirm arg of -b", cl.getOptionValue("b").equals("file"));
assertTrue("Confirm NO of extra args", cl.getArgList().size() == 0);
}
@Test
public void testOptionAndRequiredOption() throws Exception
{
String[] args = new String[] { "-a", "-b", "file" };
Options options = new Options();
options.addOption("a", "enable-a", false, null);
options.addOption(OptionBuilder.withLongOpt("bfile").hasArg().isRequired().create('b'));
CommandLine cl = parser.parse(options,args);
assertTrue("Confirm -a is set", cl.hasOption("a"));
assertTrue("Confirm -b is set", cl.hasOption("b"));
assertTrue("Confirm arg of -b", cl.getOptionValue("b").equals("file"));
assertTrue("Confirm NO of extra args", cl.getArgList().size() == 0);
}
@Test
public void testMissingRequiredOption()
{
String[] args = new String[] { "-a" };
Options options = new Options();
options.addOption("a", "enable-a", false, null);
options.addOption(OptionBuilder.withLongOpt("bfile").hasArg().isRequired().create('b'));
try
{
parser.parse(options,args);
fail("exception should have been thrown");
}
catch (MissingOptionException e)
{
assertEquals( "Incorrect exception message", "Missing required option: b", e.getMessage() );
assertTrue(e.getMissingOptions().contains("b"));
}
catch (ParseException e)
{
fail("expected to catch MissingOptionException");
}
}
@Test
public void testMissingRequiredOptions()
{
String[] args = new String[] { "-a" };
Options options = new Options();
options.addOption("a", "enable-a", false, null);
options.addOption(OptionBuilder.withLongOpt("bfile").hasArg().isRequired().create('b'));
options.addOption(OptionBuilder.withLongOpt("cfile").hasArg().isRequired().create('c'));
try
{
parser.parse(options,args);
fail("exception should have been thrown");
}
catch (MissingOptionException e)
{
assertEquals("Incorrect exception message", "Missing required options: b, c", e.getMessage());
assertTrue(e.getMissingOptions().contains("b"));
assertTrue(e.getMissingOptions().contains("c"));
}
catch (ParseException e)
{
fail("expected to catch MissingOptionException");
}
}
@Test
public void testMissingRequiredGroup() throws Exception
{
OptionGroup group = new OptionGroup();
group.addOption(OptionBuilder.create("a"));
group.addOption(OptionBuilder.create("b"));
group.setRequired(true);
Options options = new Options();
options.addOptionGroup(group);
options.addOption(OptionBuilder.isRequired().create("c"));
try
{
parser.parse(options, new String[] { "-c" });
fail("MissingOptionException not thrown");
}
catch (MissingOptionException e)
{
assertEquals(1, e.getMissingOptions().size());
assertTrue(e.getMissingOptions().get(0) instanceof OptionGroup);
}
catch (ParseException e)
{
fail("Expected to catch MissingOptionException");
}
}
@Test
public void testOptionGroup() throws Exception
{
OptionGroup group = new OptionGroup();
group.addOption(OptionBuilder.create("a"));
group.addOption(OptionBuilder.create("b"));
Options options = new Options();
options.addOptionGroup(group);
parser.parse(options, new String[] { "-b" });
assertEquals("selected option", "b", group.getSelected());
}
@Test
public void testOptionGroupLong() throws Exception
{
OptionGroup group = new OptionGroup();
group.addOption(OptionBuilder.withLongOpt("foo").create());
group.addOption(OptionBuilder.withLongOpt("bar").create());
Options options = new Options();
options.addOptionGroup(group);
CommandLine cl = parser.parse(options, new String[] { "--bar" });
assertTrue(cl.hasOption("bar"));
assertEquals("selected option", "bar", group.getSelected());
}
@Test
public void testReuseOptionsTwice() throws Exception
{
Options opts = new Options();
opts.addOption(OptionBuilder.isRequired().create('v'));
// first parsing
parser.parse(opts, new String[] { "-v" });
try
{
// second parsing, with the same Options instance and an invalid command line
parser.parse(opts, new String[0]);
fail("MissingOptionException not thrown");
}
catch (MissingOptionException e)
{
// expected
}
}
@Test
public void testBursting() throws Exception
{
String[] args = new String[] { "-acbtoast", "foo", "bar" };
CommandLine cl = parser.parse(options, args);
assertTrue( "Confirm -a is set", cl.hasOption("a") );
assertTrue( "Confirm -b is set", cl.hasOption("b") );
assertTrue( "Confirm -c is set", cl.hasOption("c") );
assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
assertTrue( "Confirm size of extra args", cl.getArgList().size() == 2);
}
@Test
public void testUnrecognizedOptionWithBursting() throws Exception
{
String[] args = new String[] { "-adbtoast", "foo", "bar" };
try
{
parser.parse(options, args);
fail("UnrecognizedOptionException wasn't thrown");
}
catch (UnrecognizedOptionException e)
{
assertEquals("-adbtoast", e.getOption());
}
}
@Test
public void testMissingArgWithBursting() throws Exception
{
String[] args = new String[] { "-acb" };
boolean caught = false;
try
{
parser.parse(options, args);
}
catch (MissingArgumentException e)
{
caught = true;
assertEquals("option missing an argument", "b", e.getOption().getOpt());
}
assertTrue( "Confirm MissingArgumentException caught", caught );
}
@Test
public void testStopBursting() throws Exception
{
String[] args = new String[] { "-azc" };
CommandLine cl = parser.parse(options, args, true);
assertTrue( "Confirm -a is set", cl.hasOption("a") );
assertFalse( "Confirm -c is not set", cl.hasOption("c") );
assertTrue( "Confirm 1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
assertTrue(cl.getArgList().contains("zc"));
}
@Test
public void testStopBursting2() throws Exception
{
String[] args = new String[] { "-c", "foobar", "-btoast" };
CommandLine cl = parser.parse(options, args, true);
assertTrue("Confirm -c is set", cl.hasOption("c"));
assertTrue("Confirm 2 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 2);
cl = parser.parse(options, cl.getArgs());
assertTrue("Confirm -c is not set", !cl.hasOption("c"));
assertTrue("Confirm -b is set", cl.hasOption("b"));
assertTrue("Confirm arg of -b", cl.getOptionValue("b").equals("toast"));
assertTrue("Confirm 1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
assertTrue("Confirm value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("foobar"));
}
@Test
public void testUnlimitedArgs() throws Exception
{
String[] args = new String[]{"-e", "one", "two", "-f", "alpha"};
Options options = new Options();
options.addOption(OptionBuilder.hasArgs().create("e"));
options.addOption(OptionBuilder.hasArgs().create("f"));
CommandLine cl = parser.parse(options, args);
assertTrue("Confirm -e is set", cl.hasOption("e"));
assertEquals("number of arg for -e", 2, cl.getOptionValues("e").length);
assertTrue("Confirm -f is set", cl.hasOption("f"));
assertEquals("number of arg for -f", 1, cl.getOptionValues("f").length);
}
@SuppressWarnings("deprecation")
private CommandLine parse(CommandLineParser parser, Options opts, String[] args, Properties properties) throws ParseException {
if (parser instanceof Parser) {
return ((Parser) parser).parse(opts, args, properties);
} else if (parser instanceof DefaultParser) {
return ((DefaultParser) parser).parse(opts, args, properties);
} else {
throw new UnsupportedOperationException("Default options not supported by this parser");
}
}
@Test
public void testPropertyOptionSingularValue() throws Exception
{
Options opts = new Options();
opts.addOption(OptionBuilder.hasOptionalArgs(2).withLongOpt("hide").create());
Properties properties = new Properties();
properties.setProperty( "hide", "seek" );
CommandLine cmd = parse(parser, opts, null, properties);
assertTrue( cmd.hasOption("hide") );
assertEquals( "seek", cmd.getOptionValue("hide") );
assertTrue( !cmd.hasOption("fake") );
}
@Test
public void testPropertyOptionFlags() throws Exception
{
Options opts = new Options();
opts.addOption("a", false, "toggle -a");
opts.addOption("c", "c", false, "toggle -c");
opts.addOption(OptionBuilder.hasOptionalArg().create('e'));
Properties properties = new Properties();
properties.setProperty("a", "true");
properties.setProperty("c", "yes");
properties.setProperty("e", "1");
CommandLine cmd = parse(parser, opts, null, properties);
assertTrue(cmd.hasOption("a"));
assertTrue(cmd.hasOption("c"));
assertTrue(cmd.hasOption("e"));
properties = new Properties();
properties.setProperty("a", "false");
properties.setProperty("c", "no");
properties.setProperty("e", "0");
cmd = parse(parser, opts, null, properties);
assertTrue(!cmd.hasOption("a"));
assertTrue(!cmd.hasOption("c"));
assertTrue(cmd.hasOption("e")); // this option accepts an argument
properties = new Properties();
properties.setProperty("a", "TRUE");
properties.setProperty("c", "nO");
properties.setProperty("e", "TrUe");
cmd = parse(parser, opts, null, properties);
assertTrue(cmd.hasOption("a"));
assertTrue(!cmd.hasOption("c"));
assertTrue(cmd.hasOption("e"));
properties = new Properties();
properties.setProperty("a", "just a string");
properties.setProperty("e", "");
cmd = parse(parser, opts, null, properties);
assertTrue(!cmd.hasOption("a"));
assertTrue(!cmd.hasOption("c"));
assertTrue(cmd.hasOption("e"));
properties = new Properties();
properties.setProperty("a", "0");
properties.setProperty("c", "1");
cmd = parse(parser, opts, null, properties);
assertTrue(!cmd.hasOption("a"));
assertTrue(cmd.hasOption("c"));
}
@Test
public void testPropertyOptionMultipleValues() throws Exception
{
Options opts = new Options();
opts.addOption(OptionBuilder.hasArgs().withValueSeparator(',').create('k'));
Properties properties = new Properties();
properties.setProperty( "k", "one,two" );
String[] values = new String[] { "one", "two" };
CommandLine cmd = parse(parser, opts, null, properties);
assertTrue( cmd.hasOption("k") );
assertTrue( Arrays.equals( values, cmd.getOptionValues('k') ) );
}
@Test
public void testPropertyOverrideValues() throws Exception
{
Options opts = new Options();
opts.addOption(OptionBuilder.hasOptionalArgs(2).create('i'));
opts.addOption(OptionBuilder.hasOptionalArgs().create('j'));
String[] args = new String[] { "-j", "found", "-i", "ink" };
Properties properties = new Properties();
properties.setProperty( "j", "seek" );
CommandLine cmd = parse(parser, opts, args, properties);
assertTrue( cmd.hasOption("j") );
assertEquals( "found", cmd.getOptionValue("j") );
assertTrue( cmd.hasOption("i") );
assertEquals( "ink", cmd.getOptionValue("i") );
assertTrue( !cmd.hasOption("fake") );
}
@Test
public void testPropertyOptionRequired() throws Exception
{
Options opts = new Options();
opts.addOption(OptionBuilder.isRequired().create("f"));
Properties properties = new Properties();
properties.setProperty("f", "true");
CommandLine cmd = parse(parser, opts, null, properties);
assertTrue(cmd.hasOption("f"));
}
@Test
public void testPropertyOptionUnexpected() throws Exception
{
Options opts = new Options();
Properties properties = new Properties();
properties.setProperty("f", "true");
try {
parse(parser, opts, null, properties);
fail("UnrecognizedOptionException expected");
} catch (UnrecognizedOptionException e) {
// expected
}
}
@Test
public void testPropertyOptionGroup() throws Exception
{
Options opts = new Options();
OptionGroup group1 = new OptionGroup();
group1.addOption(new Option("a", null));
group1.addOption(new Option("b", null));
opts.addOptionGroup(group1);
OptionGroup group2 = new OptionGroup();
group2.addOption(new Option("x", null));
group2.addOption(new Option("y", null));
opts.addOptionGroup(group2);
String[] args = new String[] { "-a" };
Properties properties = new Properties();
properties.put("b", "true");
properties.put("x", "true");
CommandLine cmd = parse(parser, opts, args, properties);
assertTrue(cmd.hasOption("a"));
assertFalse(cmd.hasOption("b"));
assertTrue(cmd.hasOption("x"));
assertFalse(cmd.hasOption("y"));
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/PatternOptionBuilderTest.java 0100644 0000765 0000024 00000017332 12537250704 031732 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.File;
import java.net.URL;
import java.util.Calendar;
import java.util.Date;
import java.util.Vector;
import org.junit.Test;
/**
* Test case for the PatternOptionBuilder class.
*/
@SuppressWarnings("deprecation") // tests some deprecated classes
public class PatternOptionBuilderTest
{
@Test
public void testSimplePattern() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("a:b@cde>f+n%t/m*z#");
String[] args = new String[] {"-c", "-a", "foo", "-b", "java.util.Vector", "-e", "build.xml", "-f", "java.util.Calendar", "-n", "4.5", "-t", "http://commons.apache.org", "-z", "Thu Jun 06 17:48:57 EDT 2002", "-m", "test*"};
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options, args);
assertEquals("flag a", "foo", line.getOptionValue("a"));
assertEquals("string flag a", "foo", line.getOptionObject("a"));
assertEquals("object flag b", new Vector(), line.getOptionObject("b"));
assertTrue("boolean true flag c", line.hasOption("c"));
assertFalse("boolean false flag d", line.hasOption("d"));
assertEquals("file flag e", new File("build.xml"), line.getOptionObject("e"));
assertEquals("class flag f", Calendar.class, line.getOptionObject("f"));
assertEquals("number flag n", new Double(4.5), line.getOptionObject("n"));
assertEquals("url flag t", new URL("http://commons.apache.org"), line.getOptionObject("t"));
// tests the char methods of CommandLine that delegate to the String methods
assertEquals("flag a", "foo", line.getOptionValue('a'));
assertEquals("string flag a", "foo", line.getOptionObject('a'));
assertEquals("object flag b", new Vector(), line.getOptionObject('b'));
assertTrue("boolean true flag c", line.hasOption('c'));
assertFalse("boolean false flag d", line.hasOption('d'));
assertEquals("file flag e", new File("build.xml"), line.getOptionObject('e'));
assertEquals("class flag f", Calendar.class, line.getOptionObject('f'));
assertEquals("number flag n", new Double(4.5), line.getOptionObject('n'));
assertEquals("url flag t", new URL("http://commons.apache.org"), line.getOptionObject('t'));
// FILES NOT SUPPORTED YET
try {
assertEquals("files flag m", new File[0], line.getOptionObject('m'));
fail("Multiple files are not supported yet, should have failed");
} catch(UnsupportedOperationException uoe) {
// expected
}
// DATES NOT SUPPORTED YET
try {
assertEquals("date flag z", new Date(1023400137276L), line.getOptionObject('z'));
fail("Date is not supported yet, should have failed");
} catch(UnsupportedOperationException uoe) {
// expected
}
}
@Test
public void testEmptyPattern() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("");
assertTrue(options.getOptions().isEmpty());
}
@Test
public void testUntypedPattern() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("abc");
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-abc" });
assertTrue(line.hasOption('a'));
assertNull("value a", line.getOptionObject('a'));
assertTrue(line.hasOption('b'));
assertNull("value b", line.getOptionObject('b'));
assertTrue(line.hasOption('c'));
assertNull("value c", line.getOptionObject('c'));
}
@Test
public void testNumberPattern() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("n%d%x%");
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-n", "1", "-d", "2.1", "-x", "3,5" });
assertEquals("n object class", Long.class, line.getOptionObject("n").getClass());
assertEquals("n value", new Long(1), line.getOptionObject("n"));
assertEquals("d object class", Double.class, line.getOptionObject("d").getClass());
assertEquals("d value", new Double(2.1), line.getOptionObject("d"));
assertNull("x object", line.getOptionObject("x"));
}
@Test
public void testClassPattern() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("c+d+");
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-c", "java.util.Calendar", "-d", "System.DateTime" });
assertEquals("c value", Calendar.class, line.getOptionObject("c"));
assertNull("d value", line.getOptionObject("d"));
}
@Test
public void testObjectPattern() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("o@i@n@");
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-o", "java.lang.String", "-i", "java.util.Calendar", "-n", "System.DateTime" });
assertEquals("o value", "", line.getOptionObject("o"));
assertNull("i value", line.getOptionObject("i"));
assertNull("n value", line.getOptionObject("n"));
}
@Test
public void testURLPattern() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("u/v/");
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-u", "http://commons.apache.org", "-v", "foo://commons.apache.org" });
assertEquals("u value", new URL("http://commons.apache.org"), line.getOptionObject("u"));
assertNull("v value", line.getOptionObject("v"));
}
@Test
public void testExistingFilePattern() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("f<");
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-f", "test.properties" });
assertEquals("f value", new File("test.properties"), line.getOptionObject("f"));
// todo test if an error is returned if the file doesn't exists (when it's implemented)
}
@Test
public void testRequiredOption() throws Exception
{
Options options = PatternOptionBuilder.parsePattern("!n%m%");
CommandLineParser parser = new PosixParser();
try
{
parser.parse(options, new String[]{""});
fail("MissingOptionException wasn't thrown");
}
catch (MissingOptionException e)
{
assertEquals(1, e.getMissingOptions().size());
assertTrue(e.getMissingOptions().contains("n"));
}
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/PosixParserTest.java 0100644 0000765 0000024 00000004430 12537250704 030067 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import org.junit.Before;
/**
* Test case for the PosixParser.
*/
public class PosixParserTest extends ParserTestCase
{
@SuppressWarnings("deprecation")
@Before
public void setUp()
{
super.setUp();
parser = new PosixParser();
}
@Override
public void testDoubleDash2() throws Exception
{
// not supported by the PosixParser
}
@Override
public void testLongWithoutEqualSingleDash() throws Exception
{
// not supported by the PosixParser
}
@Override
public void testAmbiguousLongWithoutEqualSingleDash() throws Exception
{
// not supported by the PosixParser
}
@Override
public void testNegativeOption() throws Exception
{
// not supported by the PosixParser (CLI-184)
}
@Override
public void testLongWithUnexpectedArgument1() throws Exception
{
// not supported by the PosixParser
}
@Override
public void testLongWithEqualSingleDash() throws Exception
{
// not supported by the PosixParser
}
@Override
public void testShortWithEqual() throws Exception
{
// not supported by the PosixParser
}
@Override
public void testUnambiguousPartialLongOption4() throws Exception
{
// not supported by the PosixParser
}
@Override
public void testAmbiguousPartialLongOption4() throws Exception
{
// not supported by the PosixParser
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/UtilTest.java 0100644 0000765 0000024 00000003366 12537250704 026534 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import org.junit.Test;
public class UtilTest
{
@Test
public void testStripLeadingHyphens()
{
assertEquals("f", Util.stripLeadingHyphens("-f"));
assertEquals("foo", Util.stripLeadingHyphens("--foo"));
assertEquals("-foo", Util.stripLeadingHyphens("---foo"));
assertNull(Util.stripLeadingHyphens(null));
}
@Test
public void testStripLeadingAndTrailingQuotes()
{
assertEquals("foo", Util.stripLeadingAndTrailingQuotes("\"foo\""));
assertEquals("foo \"bar\"", Util.stripLeadingAndTrailingQuotes("foo \"bar\""));
assertEquals("\"foo\" bar", Util.stripLeadingAndTrailingQuotes("\"foo\" bar"));
assertEquals("\"foo\" and \"bar\"", Util.stripLeadingAndTrailingQuotes("\"foo\" and \"bar\""));
assertEquals("\"", Util.stripLeadingAndTrailingQuotes("\""));
}
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/ValuesTest.java 0100644 0000765 0000024 00000015274 12537250704 027057 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class ValuesTest
{
private CommandLine cmd;
@Before
public void setUp() throws Exception
{
Options options = new Options();
options.addOption("a", false, "toggle -a");
options.addOption("b", true, "set -b");
options.addOption("c", "c", false, "toggle -c");
options.addOption("d", "d", true, "set -d");
options.addOption(OptionBuilder.withLongOpt("e").hasArgs().withDescription("set -e ").create('e'));
options.addOption("f", "f", false, "jk");
options.addOption(OptionBuilder.withLongOpt("g").hasArgs(2).withDescription("set -g").create('g'));
options.addOption(OptionBuilder.withLongOpt("h").hasArg().withDescription("set -h").create('h'));
options.addOption(OptionBuilder.withLongOpt("i").withDescription("set -i").create('i'));
options.addOption(OptionBuilder.withLongOpt("j").hasArgs().withDescription("set -j").withValueSeparator('=').create('j'));
options.addOption(OptionBuilder.withLongOpt("k").hasArgs().withDescription("set -k").withValueSeparator('=').create('k'));
options.addOption(OptionBuilder.withLongOpt("m").hasArgs().withDescription("set -m").withValueSeparator().create('m'));
String[] args = new String[] { "-a",
"-b", "foo",
"--c",
"--d", "bar",
"-e", "one", "two",
"-f",
"arg1", "arg2",
"-g", "val1", "val2" , "arg3",
"-h", "val1", "-i",
"-h", "val2",
"-jkey=value",
"-j", "key=value",
"-kkey1=value1",
"-kkey2=value2",
"-mkey=value"};
CommandLineParser parser = new PosixParser();
cmd = parser.parse(options,args);
}
@Test
public void testShortArgs()
{
assertTrue("Option a is not set", cmd.hasOption("a"));
assertTrue("Option c is not set", cmd.hasOption("c"));
assertNull(cmd.getOptionValues("a"));
assertNull(cmd.getOptionValues("c"));
}
@Test
public void testShortArgsWithValue()
{
assertTrue("Option b is not set", cmd.hasOption("b"));
assertTrue(cmd.getOptionValue("b").equals("foo"));
assertEquals(1, cmd.getOptionValues("b").length);
assertTrue("Option d is not set", cmd.hasOption("d"));
assertTrue(cmd.getOptionValue("d").equals("bar"));
assertEquals(1, cmd.getOptionValues("d").length);
}
@Test
public void testMultipleArgValues()
{
assertTrue("Option e is not set", cmd.hasOption("e"));
assertArrayEquals(new String[] { "one", "two" }, cmd.getOptionValues("e"));
}
@Test
public void testTwoArgValues()
{
assertTrue("Option g is not set", cmd.hasOption("g"));
assertArrayEquals(new String[] { "val1", "val2" }, cmd.getOptionValues("g"));
}
@Test
public void testComplexValues()
{
assertTrue("Option i is not set", cmd.hasOption("i"));
assertTrue("Option h is not set", cmd.hasOption("h"));
assertArrayEquals(new String[] { "val1", "val2" }, cmd.getOptionValues("h"));
}
@Test
public void testExtraArgs()
{
assertArrayEquals("Extra args", new String[] { "arg1", "arg2", "arg3" }, cmd.getArgs());
}
@Test
public void testCharSeparator()
{
// tests the char methods of CommandLine that delegate to the String methods
assertTrue("Option j is not set", cmd.hasOption("j"));
assertTrue("Option j is not set", cmd.hasOption('j'));
assertArrayEquals(new String[] { "key", "value", "key", "value" }, cmd.getOptionValues("j"));
assertArrayEquals(new String[] { "key", "value", "key", "value" }, cmd.getOptionValues('j'));
assertTrue("Option k is not set", cmd.hasOption("k"));
assertTrue("Option k is not set", cmd.hasOption('k'));
assertArrayEquals(new String[] { "key1", "value1", "key2", "value2" }, cmd.getOptionValues("k"));
assertArrayEquals(new String[] { "key1", "value1", "key2", "value2" }, cmd.getOptionValues('k'));
assertTrue("Option m is not set", cmd.hasOption("m"));
assertTrue("Option m is not set", cmd.hasOption('m'));
assertArrayEquals(new String[] { "key", "value" }, cmd.getOptionValues("m"));
assertArrayEquals(new String[] { "key", "value" }, cmd.getOptionValues('m'));
}
/**
* jkeyes - commented out this test as the new architecture
* breaks this type of functionality. I have left the test
* here in case I get a brainwave on how to resolve this.
*/
/*
public void testGetValue()
{
// the 'm' option
assertTrue( _option.getValues().length == 2 );
assertEquals( _option.getValue(), "key" );
assertEquals( _option.getValue( 0 ), "key" );
assertEquals( _option.getValue( 1 ), "value" );
try {
assertEquals( _option.getValue( 2 ), "key" );
fail( "IndexOutOfBounds not caught" );
}
catch( IndexOutOfBoundsException exp ) {
}
try {
assertEquals( _option.getValue( -1 ), "key" );
fail( "IndexOutOfBounds not caught" );
}
catch( IndexOutOfBoundsException exp ) {
}
}
*/
}
commons-cli-1.3.1-src/src/test/java/org/apache/commons/cli/ValueTest.java 0100644 0000765 0000024 00000014541 12537250704 026670 0 ustar 00bene staff 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.cli;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
@SuppressWarnings("deprecation") // tests some deprecated classes
public class ValueTest
{
private CommandLine _cl = null;
private final Options opts = new Options();
@Before
public void setUp() throws Exception
{
opts.addOption("a", false, "toggle -a");
opts.addOption("b", true, "set -b");
opts.addOption("c", "c", false, "toggle -c");
opts.addOption("d", "d", true, "set -d");
opts.addOption(OptionBuilder.hasOptionalArg().create('e'));
opts.addOption(OptionBuilder.hasOptionalArg().withLongOpt("fish").create());
opts.addOption(OptionBuilder.hasOptionalArgs().withLongOpt("gravy").create());
opts.addOption(OptionBuilder.hasOptionalArgs(2).withLongOpt("hide").create());
opts.addOption(OptionBuilder.hasOptionalArgs(2).create('i'));
opts.addOption(OptionBuilder.hasOptionalArgs().create('j'));
String[] args = new String[] { "-a",
"-b", "foo",
"--c",
"--d", "bar"
};
Parser parser = new PosixParser();
_cl = parser.parse(opts,args);
}
@Test
public void testShortNoArg()
{
assertTrue( _cl.hasOption("a") );
assertNull( _cl.getOptionValue("a") );
}
@Test
public void testShortWithArg()
{
assertTrue( _cl.hasOption("b") );
assertNotNull( _cl.getOptionValue("b") );
assertEquals( _cl.getOptionValue("b"), "foo");
}
@Test
public void testLongNoArg()
{
assertTrue( _cl.hasOption("c") );
assertNull( _cl.getOptionValue("c") );
}
@Test
public void testLongWithArg()
{
assertTrue( _cl.hasOption("d") );
assertNotNull( _cl.getOptionValue("d") );
assertEquals( _cl.getOptionValue("d"), "bar");
}
@Test
public void testShortOptionalArgNoValue() throws Exception
{
String[] args = new String[] { "-e" };
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts,args);
assertTrue( cmd.hasOption("e") );
assertNull( cmd.getOptionValue("e") );
}
@Test
public void testShortOptionalArgValue() throws Exception
{
String[] args = new String[] { "-e", "everything" };
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts,args);
assertTrue( cmd.hasOption("e") );
assertEquals( "everything", cmd.getOptionValue("e") );
}
@Test
public void testLongOptionalNoValue() throws Exception
{
String[] args = new String[] { "--fish" };
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts,args);
assertTrue( cmd.hasOption("fish") );
assertNull( cmd.getOptionValue("fish") );
}
@Test
public void testLongOptionalArgValue() throws Exception
{
String[] args = new String[] { "--fish", "face" };
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts,args);
assertTrue( cmd.hasOption("fish") );
assertEquals( "face", cmd.getOptionValue("fish") );
}
@Test
public void testShortOptionalArgValues() throws Exception
{
String[] args = new String[] { "-j", "ink", "idea" };
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts,args);
assertTrue( cmd.hasOption("j") );
assertEquals( "ink", cmd.getOptionValue("j") );
assertEquals( "ink", cmd.getOptionValues("j")[0] );
assertEquals( "idea", cmd.getOptionValues("j")[1] );
assertEquals( cmd.getArgs().length, 0 );
}
@Test
public void testLongOptionalArgValues() throws Exception
{
String[] args = new String[] { "--gravy", "gold", "garden" };
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts,args);
assertTrue( cmd.hasOption("gravy") );
assertEquals( "gold", cmd.getOptionValue("gravy") );
assertEquals( "gold", cmd.getOptionValues("gravy")[0] );
assertEquals( "garden", cmd.getOptionValues("gravy")[1] );
assertEquals( cmd.getArgs().length, 0 );
}
@Test
public void testShortOptionalNArgValues() throws Exception
{
String[] args = new String[] { "-i", "ink", "idea", "isotope", "ice" };
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts,args);
assertTrue( cmd.hasOption("i") );
assertEquals( "ink", cmd.getOptionValue("i") );
assertEquals( "ink", cmd.getOptionValues("i")[0] );
assertEquals( "idea", cmd.getOptionValues("i")[1] );
assertEquals( cmd.getArgs().length, 2 );
assertEquals( "isotope", cmd.getArgs()[0] );
assertEquals( "ice", cmd.getArgs()[1] );
}
@Test
public void testLongOptionalNArgValues() throws Exception
{
String[] args = new String[] {
"--hide", "house", "hair", "head"
};
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts,args);
assertTrue( cmd.hasOption("hide") );
assertEquals( "house", cmd.getOptionValue("hide") );
assertEquals( "house", cmd.getOptionValues("hide")[0] );
assertEquals( "hair", cmd.getOptionValues("hide")[1] );
assertEquals( cmd.getArgs().length, 1 );
assertEquals( "head", cmd.getArgs()[0] );
}
}