class OptionParser

Parent:: Object

OptionParser

Introduction

OptionParser is a class for command-line option analysis. It is much more advanced, yet also easier to use, than GetoptLong, and is a more Ruby-oriented solution.

Features

The argument specification and the code to handle it are written in the same place.
It can output an option summary; you don't need to maintain this string separately.
Optional and mandatory arguments are specified very gracefully.
Arguments can be automatically converted to a specified class.
Arguments can be restricted to a certain set.

All of these features are demonstrated in the examples below. See make_switch for full documentation.

Minimal example

require 'optparse'

options = {}
OptionParser.new do |opts|
  opts.banner = "Usage: example.rb [options]"

  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
    options[:verbose] = v
  end
end.parse!

p options
p ARGV

Generating Help

OptionParser can be used to automatically generate help for the commands you write:

require 'optparse'

Options = Struct.new(:name)

class Parser
  def self.parse(options)
    args = Options.new("world")

    opt_parser = OptionParser.new do |opts|
      opts.banner = "Usage: example.rb [options]"

      opts.on("-nNAME", "--name=NAME", "Name to say hello to") do |n|
        args.name = n
      end

      opts.on("-h", "--help", "Prints this help") do
        puts opts
        exit
      end
    end

    opt_parser.parse!(options)
    return args
  end
end
options = Parser.parse %w[--help]

#=>
   # Usage: example.rb [options]
   #     -n, --name=NAME                  Name to say hello to
   #     -h, --help                       Prints this help#

Complete example

The following example is a complete Ruby program. You can run it and see the effect of specifying various options. This is probably the best way to learn the features of optparse.

require 'optparse'
require 'optparse/time'
require 'ostruct'
require 'pp'

class OptparseExample

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

  #
  # Return a structure describing the options.
  #
  def self.parse(args)
    # The options specified on the command line will be collected in *options*.
    # We set default values here.
    options = OpenStruct.new
    options.library = []
    options.inplace = false
    options.encoding = "utf8"
    options.transfer_type = :auto
    options.verbose = false

    opt_parser = OptionParser.new do |opts|
      opts.banner = "Usage: example.rb [options]"

      opts.separator ""
      opts.separator "Specific options:"

      # Mandatory argument.
      opts.on("-r", "--require LIBRARY",
              "Require the LIBRARY before executing your script") do |lib|
        options.library << lib
      end

      # Optional argument; multi-line description.
      opts.on("-i", "--inplace [EXTENSION]",
              "Edit ARGV files in place",
              "  (make backup if EXTENSION supplied)") do |ext|
        options.inplace = true
        options.extension = ext || ''
        options.extension.sub!(/\A\.?(?=.)/, ".")  # Ensure extension begins with dot.
      end

      # Cast 'delay' argument to a Float.
      opts.on("--delay N", Float, "Delay N seconds before executing") do |n|
        options.delay = n
      end

      # Cast 'time' argument to a Time object.
      opts.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
        options.time = time
      end

      # Cast to octal integer.
      opts.on("-F", "--irs [OCTAL]", OptionParser::OctalInteger,
              "Specify record separator (default \\0)") do |rs|
        options.record_separator = rs
      end

      # List of arguments.
      opts.on("--list x,y,z", Array, "Example 'list' of arguments") do |list|
        options.list = list
      end

      # Keyword completion.  We are specifying a specific set of arguments (CODES
      # and CODE_ALIASES - notice the latter is a Hash), and the user may provide
      # the shortest unambiguous text.
      code_list = (CODE_ALIASES.keys + CODES).join(',')
      opts.on("--code CODE", CODES, CODE_ALIASES, "Select encoding",
              "  (#{code_list})") do |encoding|
        options.encoding = encoding
      end

      # Optional argument with keyword completion.
      opts.on("--type [TYPE]", [:text, :binary, :auto],
              "Select transfer type (text, binary, auto)") do |t|
        options.transfer_type = t
      end

      # Boolean switch.
      opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
        options.verbose = v
      end

      opts.separator ""
      opts.separator "Common options:"

      # No argument, shows at tail.  This will print an options summary.
      # Try it and see!
      opts.on_tail("-h", "--help", "Show this message") do
        puts opts
        exit
      end

      # Another typical switch to print the version.
      opts.on_tail("--version", "Show version") do
        puts ::Version.join('.')
        exit
      end
    end

    opt_parser.parse!(args)
    options
  end  # parse()

end  # class OptparseExample

options = OptparseExample.parse(ARGV)
pp options
pp ARGV

Shell Completion

For modern shells (e.g. bash, zsh, etc.), you can use shell completion for command line options.

Further documentation

The above examples should be enough to learn how to use this class. If you have any questions, file a ticket at bugs.ruby-lang.org.

Constants

DecimalInteger: Decimal integer format, to be converted to Integer.
DecimalNumeric: Decimal integer/float number format, to be converted to Integer for integer format, Float for float format.
OctalInteger: Ruby/C like octal/hexadecimal/binary integer format, to be converted to Integer.

Attributes

Heading banner preceding summary.

default_argv[RW]

Strings to be parsed in default.

program_name[W]

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

release[W]

Release code

set_banner[W]

Heading banner preceding summary.

set_program_name[W]

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

set_summary_indent[RW]

Indentation for summary. Must be String (or have + String method).

set_summary_width[RW]

Width for option list portion of summary. Must be Numeric.

summary_indent[RW]

Indentation for summary. Must be String (or have + String method).

summary_width[RW]

Width for option list portion of summary. Must be Numeric.

version[W]

Version

Public Class Methods

accept(*args, &blk) Show source

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

See accept.

each_const(path, base = ::Object) Show source

# File lib/optparse/version.rb, line 49
def each_const(path, base = ::Object)
  path.split(/::|\//).inject(base) do |klass, name|
    raise NameError, path unless Module === klass
    klass.constants.grep(/#{name}/i) do |c|
      klass.const_defined?(c) or next
      klass.const_get(c)
    end
  end
end

getopts(*args) Show source

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

See getopts.

inc(arg, default = nil) Show source

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

Returns an incremented value of default according to arg.

new(banner = nil, width = 32, indent = ' ' * 4) { |self| ... } Show source

# File lib/optparse.rb, line 909
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

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

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

reject(*args, &blk) Show source

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

See reject.

search_const(klass, name) { |klass, cname, const| ... } Show source

# File lib/optparse/version.rb, line 59
def search_const(klass, name)
  klasses = [klass]
  while klass = klasses.shift
    klass.constants.each do |cname|
      klass.const_defined?(cname) or next
      const = klass.const_get(cname)
      yield klass, cname, const if name === cname
      klasses << const if Module === const and const != ::Object
    end
  end
end

show_version(*pkgs) Show source

# File lib/optparse/version.rb, line 4
def show_version(*pkgs)
  progname = ARGV.options.program_name
  result = false
  show = proc do |klass, cname, version|
    str = "#{progname}"
    unless klass == ::Object and cname == :VERSION
      version = version.join(".") if Array === version
      str << ": #{klass}" unless klass == Object
      str << " version #{version}"
    end
    [:Release, :RELEASE].find do |rel|
      if klass.const_defined?(rel)
        str << " (#{klass.const_get(rel)})"
      end
    end
    puts str
    result = true
  end
  if pkgs.size == 1 and pkgs[0] == "all"
    self.search_const(::Object, /\AV(?:ERSION|ersion)\z/) do |klass, cname, version|
      unless cname[1] == ?e and klass.const_defined?(:Version)
        show.call(klass, cname.intern, version)
      end
    end
  else
    pkgs.each do |pkg|
      begin
        pkg = pkg.split(/::|\//).inject(::Object) {|m, c| m.const_get(c)}
        v = case
            when pkg.const_defined?(:Version)
              pkg.const_get(n = :Version)
            when pkg.const_defined?(:VERSION)
              pkg.const_get(n = :VERSION)
            else
              n = nil
              "unknown"
            end
        show.call(pkg, n, v)
      rescue NameError
      end
    end
  end
  result
end

terminate(arg = nil) Show source

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

top() Show source

# File lib/optparse.rb, line 939
def self.top() DefaultList end

with(*args, &block) Show source

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

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 = $!) Show source

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

Calls superclass method Kernel#abort

accept(*args, &blk) Show source

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

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)

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

Heading banner preceding summary.

base() Show source

# File lib/optparse.rb, line 1062
def base
  @stack[1]
end

Subject of on_tail.

candidate(word) Show source

# File lib/optparse.rb, line 1593
def candidate(word)
  list = []
  case word
  when /\A--/
    word, arg = word.split(/=/, 2)
    argpat = Completion.regexp(arg, false) if arg and !arg.empty?
    long = true
  when /\A-(!-)/
    short = true
  when /\A-/
    long = short = true
  end
  pat = Completion.regexp(word, true)
  visit(:each_option) do |opt|
    next unless Switch === opt
    opts = (long ? opt.long : []) + (short ? opt.short : [])
    opts = Completion.candidate(word, true, pat, &opts.method(:each)).map(&:first) if pat
    if /\A=/ =~ opt.arg
      opts.map! {|sw| sw + "="}
      if arg and CompletingHash === opt.pattern
        if opts = opt.pattern.candidate(arg, false, argpat)
          opts.map!(&:last)
        end
      end
    end
    list.concat(opts)
  end
  list
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) Show source

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

Also aliased as: def_option

define_head(*opts, &block) Show source

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

Also aliased as: def_head_option

define_tail(*opts, &block) Show source

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

Also aliased as: def_tail_option

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

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

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

env defaults to the basename of the program.

getopts(*args) Show source

# File lib/optparse.rb, line 1511
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|
    arg, desc = arg.split(';', 2)
    opt, val = arg.split(':', 2)
    if val
      result[opt] = val.empty? ? nil : val
      define("--#{opt}=#{result[opt] || "VAL"}", *[desc].compact)
    else
      result[opt] = false
      define("--#{opt}", *[desc].compact)
    end
  end

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

Wrapper method for getopts.rb.

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

help() Show source

# File lib/optparse.rb, line 1103
def help; summarize("#{banner}".sub(/\n?\z/, "\n")) end

Returns option summary string.

Also aliased as: to_s

inc(*args) Show source

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

load(filename = nil) Show source

# File lib/optparse.rb, line 1630
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

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) Show source

# File lib/optparse.rb, line 1187
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
  q, a = nil
  has_arg = false

  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 || Symbol === o)) and o.respond_to?(:match)
      pattern = notwice(o, pattern, 'pattern')
      if pattern.respond_to?(:convert)
        conv = pattern.method(:convert).to_proc
      else
        conv = SPLAT_PROC
      end
      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 {|pat, *v| pattern[pat] = v.fetch(0) {pat}}
    when Module
      raise ArgumentError, "unsupported argument type: #{o}", ParseError.filter_backtrace(caller(4))
    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
      else
        has_arg = true
      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?)
    if has_arg and default_style == Switch::NoArgument
      default_style = Switch::RequiredArgument
    end
    s = (style || default_style).new(pattern || default_pattern,
                                     conv, sdesc, ldesc, arg, desc, block)
  elsif !block
    if style or pattern
      raise ArgumentError, "no switch given", ParseError.filter_backtrace(caller)
    end
    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

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 #accept or #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 regular expression):

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

Argument style and description:

Instead of specifying mandatory or optional arguments 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| ... } Show source

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

Pushes a new List.

on(*opts, &block) Show source

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

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

on_head(*opts, &block) Show source

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

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

on_tail(*opts, &block) Show source

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

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

order(*argv, &block) Show source

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

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) Show source

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

Same as order, but removes switches destructively. Non-option arguments remain in argv.

parse(*argv) Show source

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

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

parse!(argv = default_argv) Show source

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

Same as parse, but removes switches destructively. Non-option arguments remain in argv.

permute(*argv) Show source

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

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

permute!(argv = default_argv) Show source

# File lib/optparse.rb, line 1473
def permute!(argv = default_argv)
  nonopts = []
  order!(argv, &nonopts.method(:<<))
  argv[0, 0] = nonopts
  argv
end

Same as permute, but removes switches destructively. Non-option arguments remain in argv.

program_name() Show source

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

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

reject(*args, &blk) Show source

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

Directs to reject specified class argument.

t: Argument class specifier, any object including Class.

reject(t)

release() Show source

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

Release code

remove() Show source

# File lib/optparse.rb, line 1081
def remove
  @stack.pop
end

Removes the last List.

separator(string) Show source

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

Add separator in summary.

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

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

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.

terminate(arg = nil) Show source

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

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

to_a() Show source

# File lib/optparse.rb, line 1109
def to_a; summarize("#{banner}".split(/^/)) end

Returns option summary list.

to_s()

Alias for: help

top() Show source

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

Subject of on / on_head, accept / reject

ver() Show source

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

Returns version string from #program_name, version and release.

version() Show source

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

Version

warn(mesg = $!) Show source

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

Calls superclass method Kernel#warn

Private Instance Methods

complete(typ, opt, icase = false, *pat) Show source

# File lib/optparse.rb, line 1582
def complete(typ, opt, icase = false, *pat)
  if pat.empty?
    search(typ, opt) {|sw| return [sw, opt]} # exact match or...
  end
  raise AmbiguousOption, catch(:ambiguous) {
    visit(:complete, typ, opt, icase, *pat) {|o, *sw| return sw}
    raise InvalidOption, opt
  }
end

Completes shortened long style option switch and returns pair of canonical switch and switch descriptor OptionParser::Switch.

id: Searching table.
opt: Searching key.
icase: Search case insensitive if true.
pat: Optional pattern for completion.

notwice(obj, prv, msg) Show source

# File lib/optparse.rb, line 1119
def notwice(obj, prv, msg)
  unless !prv or prv == obj
    raise(ArgumentError, "argument #{msg} given twice: #{obj}",
          ParseError.filter_backtrace(caller(2)))
  end
  obj
end

Checks if an argument is given twice, in which case an ArgumentError is raised. Called from OptionParser#switch only.

obj: New argument.
prv: Previously specified argument.
msg: Exception message.

search(id, key) { |k| ... } Show source

# File lib/optparse.rb, line 1565
def search(id, key)
  block_given = block_given?
  visit(:search, id, key) do |k|
    return block_given ? yield(k) : k
  end
end

Searches key in @stack for id hash and returns or yields the result.

visit(id, *args, &block) Show source

# File lib/optparse.rb, line 1554
def visit(id, *args, &block)
  @stack.reverse_each do |el|
    el.send(id, *args, &block)
  end
  nil
end

Traverses @stack, sending each element method id with args and block.

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

Docs

Docs4dev

Title here

class OptionParser

OptionParser

Introduction

Features

Minimal example

Generating Help

Complete example

Shell Completion

Further documentation

Constants

Attributes

Public Class Methods

Public Instance Methods

Private Instance Methods