File: optparse.rb

Constants

DecimalInteger	=	/\A[-+]?#{decimal}/io	Decimal integer format, to be converted to Integer.
OctalInteger	=	/\A[-+]?(?:[0-7]+(?:_[0-7]+)*\|0(?:#{binary}\|#{hex}))/io	Ruby/C like octal/hexadecimal/binary integer format, to be converted to Integer.
DecimalNumeric	=	floatpat # decimal integer is allowed as float also.	Decimal integer/float number format, to be converted to Integer for integer format, Float for float format.

External Aliases

banner=	->	set_banner
	for experimental cascading :-)
program_name=	->	set_program_name
summary_width=	->	set_summary_width
summary_indent=	->	set_summary_indent

Public Class methods

accept(*args, &blk)

See accept.

getopts(*args)

See getopts.

inc(arg, default = nil)

Returns an incremented value of default according to arg.

new(banner = nil, width = 32, indent = ' ' * 4) {|self if block_given?| ...}

Initializes the instance and yields itself if called with a block.

`banner`:	Banner message.
`width`:	Summary width.
`indent`:	Summary indent.

reject(*args, &blk)

See reject.

terminate(arg = nil)

top()

with(*args, &block)

Initializes a new instance and evaluates the optional block in context of the instance. Arguments args are passed to new, see there for description of parameters.

This method is deprecated, its behavior corresponds to the older new method.

Public Instance methods

abort(mesg = $!)

accept(*args, &blk)

Directs to accept specified class t. The argument string is passed to the block in which it should be converted to the desired class.

`t`:	Argument class specifier, any object including Class.
`pat`:	Pattern for argument, defaults to `t` if it responds to match.

  accept(t, pat, &block)

banner()

Heading banner preceding summary.

base()

Subject of on_tail.

def_head_option(*opts, &block)

Alias for define_head

def_option(*opts, &block)

Alias for define

def_tail_option(*opts, &block)

Alias for define_tail

define(*opts, &block)

define_head(*opts, &block)

define_tail(*opts, &block)

environment(env = File.basename($0, '.*'))

Parses environment variable env or its uppercase with splitting like a shell.

env defaults to the basename of the program.

getopts(*args)

Wrapper method for getopts.rb.

  params = ARGV.getopts("ab:", "foo", "bar:")
  # params[:a] = true   # -a
  # params[:b] = "1"    # -b1
  # params[:foo] = "1"  # --foo
  # params[:bar] = "x"  # --bar x

help()

Returns option summary string.

inc(*args)

load(filename = nil)

Loads options from file names as filename. Does nothing when the file is not present. Returns whether successfully loaded.

filename defaults to basename of the program without suffix in a directory ~/.options.

make_switch(opts, block = nil)

Creates an OptionParser::Switch from the parameters. The parsed argument value is passed to the given block, where it can be processed.

See at the beginning of OptionParser for some full examples.

opts can include the following elements:

Argument style:

One of the following:

  :NONE, :REQUIRED, :OPTIONAL

Argument pattern:

Acceptable option argument format, must be pre-defined with OptionParser.accept or OptionParser#accept, or Regexp. This can appear once or assigned as String if not present, otherwise causes an ArgumentError. Examples:

  Float, Time, Array

Possible argument values:

Hash or Array.

  [:text, :binary, :auto]
  %w[iso-2022-jp shift_jis euc-jp utf8 binary]
  { "jis" => "iso-2022-jp", "sjis" => "shift_jis" }

Long style switch:

Specifies a long style switch which takes a mandatory, optional or no argument. It‘s a string of the following form:

  "--switch=MANDATORY" or "--switch MANDATORY"
  "--switch[=OPTIONAL]"
  "--switch"

Short style switch:

Specifies short style switch which takes a mandatory, optional or no argument. It‘s a string of the following form:

  "-xMANDATORY"
  "-x[OPTIONAL]"
  "-x"

There is also a special form which matches character range (not full set of regural expression):

  "-[a-z]MANDATORY"
  "-[a-z][OPTIONAL]"
  "-[a-z]"

Argument style and description:

Instead of specifying mandatory or optional orguments directly in the switch parameter, this separate parameter can be used.

  "=MANDATORY"
  "=[OPTIONAL]"

Description:

Description string for the option.

  "Run verbosely"

Handler:

Handler for the parsed argument value. Either give a block or pass a Proc or Method as an argument.

new() {|self| ...}

Pushes a new List.

on(*opts, &block)

Add option switch and handler. See make_switch for an explanation of parameters.

on_head(*opts, &block)

Add option switch like with on, but at head of summary.

on_tail(*opts, &block)

Add option switch like with on, but at tail of summary.

order(*argv, &block)

Parses command line arguments argv in order. When a block is given, each non-option argument is yielded.

Returns the rest of argv left unparsed.

order!(argv = default_argv, &nonopt)

Same as order, but removes switches destructively.

parse(*argv)

Parses command line arguments argv in order when environment variable POSIXLY_CORRECT is set, and in permutation mode otherwise.

parse!(argv = default_argv)

Same as parse, but removes switches destructively.

permute(*argv)

Parses command line arguments argv in permutation mode and returns list of non-option arguments.

permute!(argv = default_argv)

Same as permute, but removes switches destructively.

program_name()

Program name to be emitted in error message and default banner, defaults to $0.

reject(*args, &blk)

Directs to reject specified class argument.

`t`:	Argument class speficier, any object including Class.

  reject(t)

release()

Release code

remove()

Removes the last List.

separator(string)

Add separator in summary.

summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk)

Puts option summary into to and returns to. Yields each line if a block is given.

`to`:	Output destination, which must have method <<. Defaults to [].
`width`:	Width of left side, defaults to @summary_width.
`max`:	Maximum length allowed for left side, defaults to `width` - 1.
`indent`:	Indentation, defaults to @summary_indent.