|
Groovy 2.2.0 | |||||||
FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | PROPERTY | CONSTR | METHOD | DETAIL: FIELD | PROPERTY | CONSTR | METHOD |
java.lang.Object groovy.util.CliBuilder
class CliBuilder extends Object
Provides a builder to assist the processing of command line arguments.
Typical usage (emulate partial arg processing of unix command: ls -alt *.groovy):
def cli = new CliBuilder(usage:'ls') cli.a('display all files') cli.l('use a long listing format') cli.t('sort by modification time') def options = cli.parse(args) assert options // would be null (false) on failure assert options.arguments() == ['*.groovy'] assert options.a && options.l && options.tThe usage message for this example (obtained using
cli.usage()
) is shown below:
usage: ls -a display all files -l use a long listing format -t sort by modification timeAn underlying parser that supports what is called argument 'bursting' is used by default. Bursting would convert '-alt' into '-a -l -t' provided no long option exists with value 'alt' and provided that none of 'a', 'l' or 't' takes an argument (in fact the last one is allowed to take an argument). The bursting behavior can be turned off by using an alternate underlying parser. The simplest way to achieve this is by setting the posix property on the CliBuilder to false, i.e. include
posix: false
in the constructor call.
Another example (partial emulation of arg processing for 'ant' command line):
def cli = new CliBuilder(usage:'ant [options] [targets]', header:'Options:') cli.help('print this message') cli.logfile(args:1, argName:'file', 'use given file for log') cli.D(args:2, valueSeparator:'=', argName:'property=value', 'use value for given property') def options = cli.parse(args) ...Usage message would be:
usage: ant [options] [targets] Options: -D <property=value> use value for given property -help print this message -logfile <file> use given file for logAnd if called with the following arguments '-logfile foo -Dbar=baz target' then the following assertions would be true:
assert options // would be null (false) on failure assert options.arguments() == ['target'] assert options.Ds == ['bar', 'baz'] assert options.logfile == 'foo'Note the use of some special notation. By adding 's' onto an option that may appear multiple times and has an argument or as in this case uses a valueSeparator to separate multiple argument values causes the list of associated argument values to be returned.
Another example showing long options (partial emulation of arg processing for 'curl' command line):
def cli = new CliBuilder(usage:'curl [options] <url>') cli._(longOpt:'basic', 'Use HTTP Basic Authentication') cli.d(longOpt:'data', args:1, argName:'data', 'HTTP POST data') cli.G(longOpt:'get', 'Send the -d data with a HTTP GET') cli.q('If used as the first parameter disables .curlrc') cli._(longOpt:'url', args:1, argName:'URL', 'Set URL to work with')Which has the following usage message:
usage: curl [options] <url> --basic Use HTTP Basic Authentication -d,--data <data> HTTP POST data -G,--get Send the -d data with a HTTP GET -q If used as the first parameter disables .curlrc --url <URL> Set URL to work withThis example shows a common convention. When mixing short and long names, the short names are often one character in size. One character options with arguments don't require a space between the option and the argument, e.g.
-Ddebug=true
. The example also shows
the use of '_' when no short option is applicable.
Also note that '_' was used multiple times. This is supported but if any other shortOpt or any longOpt is repeated, then the behavior is undefined.
Short option names may not contain a hyphen. If a long option name contains a hyphen, e.g. '--max-wait' then you can either
use the long hand method call options.hasOption('max-wait')
or surround
the option name in quotes, e.g. options.'max-wait'
.
Although CliBuilder on the whole hides away the underlying library used for processing the arguments, it does provide some hooks which let you make use of the underlying library directly should the need arise. For example, the last two lines of the 'curl' example above could be replaced with the following:
import org.apache.commons.cli.* ... as before ... cli << new Option('q', false, 'If used as the first parameter disables .curlrc') cli << OptionBuilder.withLongOpt('url').hasArg().withArgName('URL'). withDescription('Set URL to work with').create() ...CliBuilder also supports Argument File processing. If an argument starts with an '@' character followed by a filename, then the contents of the file with name filename are placed into the command line. The feature can be turned off by setting expandArgumentFiles to false. If turned on, you can still pass a real parameter with an initial '@' character by escaping it with an additional '@' symbol, e.g. '@@foo' will become '@foo' and not be subject to expansion. As an example, if the file temp.args contains the content:
-arg1 paramA paramB paramCThen calling the command line with:
someCommand
someCommand -arg1 paramA paramB paramC -arg2 paramDThis feature is particularly useful on operating systems which place limitations on the size of the command line (e.g. Windows). The feature is similar to the 'Command Line Argument File' processing supported by javadoc and javac. Consult the corresponding documentation for those tools if you wish to see further examples.
Supported Option Properties:
argName: String longOpt: String args: int optionalArg: boolean required: boolean type: Object (not currently used) valueSeparator: charSee Option for the meaning of these properties and CliBuilderTest for further examples.
Property Summary | |
---|---|
boolean |
expandArgumentFiles
Whether arguments of the form ' |
String |
footer
Optional additional message for usage; displayed after the options are displayed. |
HelpFormatter |
formatter
Normally set internally but can be overridden if you want to customise how the usage message is displayed. |
String |
header
Optional additional message for usage; displayed after the usage summary but before the options are displayed. |
Options |
options
Not normally accessed directly but full access to underlying options if needed. |
CommandLineParser |
parser
Normally set internally but allows you full customisation of the underlying processing engine. |
Boolean |
posix
To change from the default PosixParser to the GnuParser, set this to false. |
boolean |
stopAtNonOption
Indicates that option processing should continue for all arguments even if arguments not recognized as options are encountered (default true). |
String |
usage
Usage summary displayed as the first line when |
int |
width
Allows customisation of the usage message width. |
PrintWriter |
writer
Defaults to stdout but you can provide your own PrintWriter if desired. |
Method Summary | |
---|---|
static def
|
expandArgumentFiles(def args)
|
def
|
invokeMethod(String name, Object args)
Internal method: Detect option specification method calls. |
Option
|
option(def shortname, Map details, def info)
Internal method: How to create an option from the specification. |
OptionAccessor
|
parse(def args)
Make options accessible from command line args with parser. |
void
|
usage()
Print the usage message with writer (default: System.out) and formatter (default: HelpFormatter) |
Methods inherited from class Object | |
---|---|
wait, wait, wait, equals, toString, hashCode, getClass, notify, notifyAll |
Property Detail |
---|
boolean expandArgumentFiles
@
filename' will be expanded into the arguments contained within the file named filename (default true).
String footer
HelpFormatter formatter
String header
Options options
CommandLineParser parser
@Deprecated Boolean posix
boolean stopAtNonOption
String usage
cli.usage()
is called.
int width
PrintWriter writer
Method Detail |
---|
static def expandArgumentFiles(def args)
def invokeMethod(String name, Object args)
Option option(def shortname, Map details, def info)
OptionAccessor parse(def args)
void usage()
Copyright © 2003-2013 The Codehaus. All rights reserved.