File: optparse.rb

# File optparse.rb, line 824
  def self.accept(*args, &blk) top.accept(*args, &blk) end

getopts(*args)

See getopts.

[Source]

# File optparse.rb, line 1402
  def self.getopts(*args)
    new.getopts(*args)
  end

inc(arg, default = nil)

Returns an incremented value of default according to arg.

[Source]

# File optparse.rb, line 760
  def self.inc(arg, default = nil)
    case arg
    when Integer
      arg.nonzero?
    when nil
      default.to_i + 1
    end
  end

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.

[Source]

# File optparse.rb, line 779
  def initialize(banner = nil, width = 32, indent = ' ' * 4)
    @stack = [DefaultList, List.new, List.new]
    @program_name = nil
    @banner = banner
    @summary_width = width
    @summary_indent = indent
    @default_argv = ARGV
    add_officious
    yield self if block_given?
  end

reject(*args, &blk)

See reject.

[Source]

# File optparse.rb, line 837
  def self.reject(*args, &blk) top.reject(*args, &blk) end

terminate(arg = nil)

[Source]

# File optparse.rb, line 804
  def self.terminate(arg = nil)
    throw :terminate, arg
  end

top()

[Source]

# File optparse.rb, line 809
  def self.top() DefaultList end

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.

[Source]

# File optparse.rb, line 751
  def self.with(*args, &block)
    opts = new(*args)
    opts.instance_eval(&block)
    opts
  end

abort(mesg = $!)

[Source]

# File optparse.rb, line 918
  def abort(mesg = $!)
    super("#{program_name}: #{mesg}")
  end

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)

[Source]

# File optparse.rb, line 820
  def accept(*args, &blk) top.accept(*args, &blk) end

banner()

Heading banner preceding summary.

[Source]

# File optparse.rb, line 862
  def banner
    unless @banner
      @banner = "Usage: #{program_name} [options]"
      visit(:add_banner, @banner)
    end
    @banner
  end

base()

Subject of on_tail.

[Source]

# File optparse.rb, line 932
  def base
    @stack[1]
  end

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)

[Source]

# File optparse.rb, line 1178
  def define(*opts, &block)
    top.append(*(sw = make_switch(opts, block)))
    sw[0]
  end

define_head(*opts, &block)

[Source]

# File optparse.rb, line 1193
  def define_head(*opts, &block)
    top.prepend(*(sw = make_switch(opts, block)))
    sw[0]
  end

define_tail(*opts, &block)

[Source]

# File optparse.rb, line 1207
  def define_tail(*opts, &block)
    base.append(*(sw = make_switch(opts, block)))
    sw[0]
  end

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.

[Source]

# File optparse.rb, line 1477
  def environment(env = File.basename($0, '.*'))
    env = ENV[env] || ENV[env.upcase] or return
    parse(*Shellwords.shellwords(env))
  end

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

[Source]

# File optparse.rb, line 1368
  def getopts(*args)
    argv = Array === args.first ? args.shift : default_argv
    single_options, *long_options = *args

    result = {}

    single_options.scan(/(.)(:)?/) do |opt, val|
      if val
        result[opt] = nil
        define("-#{opt} VAL")
      else
        result[opt] = false
        define("-#{opt}")
      end
    end if single_options

    long_options.each do |arg|
      opt, val = arg.split(':', 2)
      if val
        result[opt] = val.empty? ? nil : val
        define("--#{opt} VAL")
      else
        result[opt] = false
        define("--#{opt}")
      end
    end

    parse_in_order(argv, result.method(:[]=))
    result
  end

help()

Returns option summary string.

[Source]

# File optparse.rb, line 972
  def help; summarize(banner.to_s.sub(/\n?\z/, "\n")) end

inc(*args)

[Source]

# File optparse.rb, line 768
  def inc(*args)
    self.class.inc(*args)
  end

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.

[Source]

# File optparse.rb, line 1457
  def load(filename = nil)
    begin
      filename ||= File.expand_path(File.basename($0, '.*'), '~/.options')
    rescue
      return false
    end
    begin
      parse(*IO.readlines(filename).each {|s| s.chomp!})
      true
    rescue Errno::ENOENT, Errno::ENOTDIR
      false
    end
  end

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.

[Source]

# File optparse.rb, line 1059
  def make_switch(opts, block = nil)
    short, long, nolong, style, pattern, conv, not_pattern, not_conv, not_style = [], [], []
    ldesc, sdesc, desc, arg = [], [], []
    default_style = Switch::NoArgument
    default_pattern = nil
    klass = nil
    o = nil
    n, q, a = nil

    opts.each do |o|
      # argument class
      next if search(:atype, o) do |pat, c|
        klass = notwice(o, klass, 'type')
        if not_style and not_style != Switch::NoArgument
          not_pattern, not_conv = pat, c
        else
          default_pattern, conv = pat, c
        end
      end

      # directly specified pattern(any object possible to match)
      if !(String === o) and o.respond_to?(:match)
        pattern = notwice(o, pattern, 'pattern')
        conv = pattern.method(:convert).to_proc if pattern.respond_to?(:convert)
        next
      end

      # anything others
      case o
      when Proc, Method
        block = notwice(o, block, 'block')
      when Array, Hash
        case pattern
        when CompletingHash
        when nil
          pattern = CompletingHash.new
          conv = pattern.method(:convert).to_proc if pattern.respond_to?(:convert)
        else
          raise ArgumentError, "argument pattern given twice"
        end
        o.each {|(o, *v)| pattern[o] = v.fetch(0) {o}}
      when Module
        raise ArgumentError, "unsupported argument type: #{o}"
      when *ArgumentStyle.keys
        style = notwice(ArgumentStyle[o], style, 'style')
      when /^--no-([^\[\]=\s]*)(.+)?/
        q, a = $1, $2
        o = notwice(a ? Object : TrueClass, klass, 'type')
        not_pattern, not_conv = search(:atype, o) unless not_style
        not_style = (not_style || default_style).guess(arg = a) if a
        default_style = Switch::NoArgument
        default_pattern, conv = search(:atype, FalseClass) unless default_pattern
        ldesc << "--no-#{q}"
        long << 'no-' + (q = q.downcase)
        nolong << q
      when /^--\[no-\]([^\[\]=\s]*)(.+)?/
        q, a = $1, $2
        o = notwice(a ? Object : TrueClass, klass, 'type')
        if a
          default_style = default_style.guess(arg = a)
          default_pattern, conv = search(:atype, o) unless default_pattern
        end
        ldesc << "--[no-]#{q}"
        long << (o = q.downcase)
        not_pattern, not_conv = search(:atype, FalseClass) unless not_style
        not_style = Switch::NoArgument
        nolong << 'no-' + o
      when /^--([^\[\]=\s]*)(.+)?/
        q, a = $1, $2
        if a
          o = notwice(NilClass, klass, 'type')
          default_style = default_style.guess(arg = a)
          default_pattern, conv = search(:atype, o) unless default_pattern
        end
        ldesc << "--#{q}"
        long << (o = q.downcase)
      when /^-(\[\^?\]?(?:[^\\\]]|\\.)*\])(.+)?/
        q, a = $1, $2
        o = notwice(Object, klass, 'type')
        if a
          default_style = default_style.guess(arg = a)
          default_pattern, conv = search(:atype, o) unless default_pattern
        end
        sdesc << "-#{q}"
        short << Regexp.new(q)
      when /^-(.)(.+)?/
        q, a = $1, $2
        if a
          o = notwice(NilClass, klass, 'type')
          default_style = default_style.guess(arg = a)
          default_pattern, conv = search(:atype, o) unless default_pattern
        end
        sdesc << "-#{q}"
        short << q
      when /^=/
        style = notwice(default_style.guess(arg = o), style, 'style')
        default_pattern, conv = search(:atype, Object) unless default_pattern
      else
        desc.push(o)
      end
    end

    default_pattern, conv = search(:atype, default_style.pattern) unless default_pattern
    if !(short.empty? and long.empty?)
      s = (style || default_style).new(pattern || default_pattern,
                                       conv, sdesc, ldesc, arg, desc, block)
    elsif !block
      raise ArgumentError, "no switch given" if style or pattern
      s = desc
    else
      short << pattern
      s = (style || default_style).new(pattern,
                                       conv, nil, nil, arg, desc, block)
    end
    return s, short, long,
      (not_style.new(not_pattern, not_conv, sdesc, ldesc, nil, desc, block) if not_style),
      nolong
  end

new() {|self| ...}

Pushes a new List.

[Source]

# File optparse.rb, line 939
  def new
    @stack.push(List.new)
    if block_given?
      yield self
    else
      self
    end
  end

on(*opts, &block)

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

[Source]

# File optparse.rb, line 1187
  def on(*opts, &block)
    define(*opts, &block)
    self
  end

on_head(*opts, &block)

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

[Source]

# File optparse.rb, line 1201
  def on_head(*opts, &block)
    define_head(*opts, &block)
    self
  end

on_tail(*opts, &block)

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

[Source]

# File optparse.rb, line 1215
  def on_tail(*opts, &block)
    define_tail(*opts, &block)
    self
  end

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.

[Source]

# File optparse.rb, line 1234
  def order(*argv, &block)
    argv = argv[0].dup if argv.size == 1 and Array === argv[0]
    order!(argv, &block)
  end

order!(argv = default_argv, &nonopt)

Same as order, but removes switches destructively.

[Source]

# File optparse.rb, line 1242
  def order!(argv = default_argv, &nonopt)
    parse_in_order(argv, &nonopt)
  end

parse(*argv)

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

[Source]

# File optparse.rb, line 1343
  def parse(*argv)
    argv = argv[0].dup if argv.size == 1 and Array === argv[0]
    parse!(argv)
  end

parse!(argv = default_argv)

Same as parse, but removes switches destructively.

[Source]

# File optparse.rb, line 1351
  def parse!(argv = default_argv)
    if ENV.include?('POSIXLY_CORRECT')
      order!(argv)
    else
      permute!(argv)
    end
  end

permute(*argv)

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

[Source]

# File optparse.rb, line 1323
  def permute(*argv)
    argv = argv[0].dup if argv.size == 1 and Array === argv[0]
    permute!(argv)
  end

permute!(argv = default_argv)

Same as permute, but removes switches destructively.

[Source]

# File optparse.rb, line 1331
  def permute!(argv = default_argv)
    nonopts = []
    arg = nil
    order!(argv) {|arg| nonopts << arg}
    argv[0, 0] = nonopts
    argv
  end

program_name()

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

[Source]

# File optparse.rb, line 874
  def program_name
    @program_name || File.basename($0, '.*')
  end

reject(*args, &blk)

Directs to reject specified class argument.

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

  reject(t)

[Source]

# File optparse.rb, line 833
  def reject(*args, &blk) top.reject(*args, &blk) end

release()

Release code

[Source]

# File optparse.rb, line 899
  def release
    @release || (defined?(::Release) && ::Release) || (defined?(::RELEASE) && ::RELEASE)
  end

remove()

Removes the last List.

[Source]

# File optparse.rb, line 951
  def remove
    @stack.pop
  end

separator(string)

Add separator in summary.

[Source]

# File optparse.rb, line 1224
  def separator(string)
    top.append(string, nil, nil)
  end

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.

[Source]

# File optparse.rb, line 964
  def summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk)
    visit(:summarize, {}, {}, width, max, indent, &(blk || proc {|l| to << l + $/}))
    to
  end

terminate(arg = nil)

Terminates option parsing. Optional parameter arg is a string pushed back to be the first non-option argument.

[Source]

# File optparse.rb, line 801
  def terminate(arg = nil)
    self.class.terminate(arg)
  end

to_a()

Returns option summary list.

[Source]

# File optparse.rb, line 978
  def to_a; summarize(banner.to_a.dup) end

to_s()

Alias for help

top()

Subject of on / on_head, accept / reject

[Source]

# File optparse.rb, line 925
  def top
    @stack[-1]
  end

ver()

Returns version string from program_name, version and release.

[Source]

# File optparse.rb, line 906
  def ver
    if v = version
      str = "#{program_name} #{[v].join('.')}"
      str << " (#{v})" if v = release
      str
    end
  end

version()

Version

[Source]

# File optparse.rb, line 892
  def version
    @version || (defined?(::Version) && ::Version)
  end

warn(mesg = $!)

[Source]

# File optparse.rb, line 914
  def warn(mesg = $!)
    super("#{program_name}: #{mesg}")
  end

Author:	Nobu Nakada
Documentation:	Nobu Nakada and Gavin Sinclair.

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.

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

optparse.rb

Methods

Constants

External Aliases

Public Class methods

Public Instance methods