Class: OptionParser

Relationships & Source Files
Namespace Children
Modules: `Acceptables`, `Arguable`, `Completion`
Classes: `AC`, `CompletingHash`, `List`, `OptionMap`, `Switch`
Exceptions: `AmbiguousArgument`, `AmbiguousOption`, `InvalidArgument`, `InvalidOption`, `MissingArgument`, `NeedlessArgument`, `ParseError`
Extension / Inclusion / Inheritance Descendants
Subclasses: AC
Inherits:	Object
Defined in:	lib/optparse.rb, lib/optparse/kwargs.rb

Overview

New to `OptionParser`?

See the Tutorial.

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 |parser|
  parser.banner = "Usage: example.rb [options]"

  parser.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 |parser|
      parser.banner = "Usage: example.rb [options]"

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

      parser.on("-h", "--help", "Prints this help") do
        puts parser
        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

Required Arguments

For options that require an argument, option specification strings may include an option name in all caps. If an option is used without the required argument, an exception will be raised.

require 'optparse'

options = {}
OptionParser.new do |parser|
  parser.on("-r", "--require LIBRARY",
            "Require the LIBRARY before executing your script") do |lib|
    puts "You required #{lib}!"
  end
end.parse!

Used:

$ ruby optparse-test.rb -r
optparse-test.rb:9:in `<main>': missing argument: -r (OptionParser::MissingArgument)
$ ruby optparse-test.rb -r my-library
You required my-library!

Type Coercion

OptionParser supports the ability to coerce command line arguments into objects for us.

OptionParser comes with a few ready-to-use kinds of type coercion. They are:

Date – Anything accepted by Date.parse (need to require optparse/date)
DateTime – Anything accepted by DateTime.parse (need to require optparse/date)
Time – Anything accepted by Time.httpdate or Time.parse (need to require optparse/time)
URI – Anything accepted by URI.parse (need to require optparse/uri)
Shellwords – Anything accepted by Shellwords.shellwords (need to require optparse/shellwords)
String – Any non-empty string
Integer – Any integer. Will convert octal. (e.g. 124, -3, 040)
Float – Any float. (e.g. 10, 3.14, -100E+13)
Numeric – Any integer, float, or rational (1, 3.4, 1/3)
DecimalInteger – Like Integer, but no octal format.
OctalInteger – Like Integer, but no decimal format.
DecimalNumeric – Decimal integer or float.
TrueClass – Accepts ‘+, yes, true, -, no, false’ and defaults as true
FalseClass – Same as TrueClass, but defaults to false
Array – Strings separated by ‘,’ (e.g. 1,2,3)
Regexp – Regular expressions. Also includes options.

We can also add our own coercions, which we will cover below.

Using Built-in Conversions

As an example, the built-in Time conversion is used. The other built-in conversions behave in the same way. OptionParser will attempt to parse the argument as a Time. If it succeeds, that time will be passed to the handler block. Otherwise, an exception will be raised.

require 'optparse'
require 'optparse/time'
OptionParser.new do |parser|
  parser.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
    p time
  end
end.parse!

Used:

$ ruby optparse-test.rb  -t nonsense
#... invalid argument: -t nonsense (OptionParser::InvalidArgument)
$ ruby optparse-test.rb  -t 10-11-12
2010-11-12 00:00:00 -0500
$ ruby optparse-test.rb  -t 9:30
2014-08-13 09:30:00 -0400

Creating Custom Conversions

The .accept method on OptionParser may be used to create converters. It specifies which conversion block to call whenever a class is specified. The example below uses it to fetch a User object before the #on handler receives it.

require 'optparse'

User = Struct.new(:id, :name)

def find_user id
  not_found = ->{ raise "No User Found for id #{id}" }
  [ User.new(1, "Sam"),
    User.new(2, "Gandalf") ].find(not_found) do |u|
    u.id == id
  end
end

op = OptionParser.new
op.accept(User) do |user_id|
  find_user user_id.to_i
end

op.on("--user ID", User) do |user|
  puts user
end

op.parse!

Used:

$ ruby optparse-test.rb --user 1
#<struct User id=1, name="Sam">
$ ruby optparse-test.rb --user 2
#<struct User id=2, name="Gandalf">
$ ruby optparse-test.rb --user 3
optparse-test.rb:15:in `block in find_user': No User Found for id 3 (RuntimeError)

Store options to a Hash

The into option of #order, #parse and so on methods stores command line options into a Hash.

require 'optparse'

options = {}
OptionParser.new do |parser|
  parser.on('-a')
  parser.on('-b NUM', Integer)
  parser.on('-v', '--verbose')
end.parse!(into: options)

p options

Used:

$ ruby optparse-test.rb -a
{:a=>true}
$ ruby optparse-test.rb -a -v
{:a=>true, :verbose=>true}
$ ruby optparse-test.rb -a -b 100
{:a=>true, :b=>100}

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
  Version = '1.0.0'

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

  class ScriptOptions
    attr_accessor :library, :inplace, :encoding, :transfer_type,
                  :verbose, :extension, :delay, :time, :record_separator,
                  :list

    def initialize
      self.library = []
      self.inplace = false
      self.encoding = "utf8"
      self.transfer_type = :auto
      self.verbose = false
    end

    def define_options(parser)
      parser.banner = "Usage: example.rb [options]"
      parser.separator ""
      parser.separator "Specific options:"

      # add additional options
      perform_inplace_option(parser)
      delay_execution_option(parser)
      execute_at_time_option(parser)
      specify_record_separator_option(parser)
      list_example_option(parser)
      specify_encoding_option(parser)
      optional_option_argument_with_keyword_completion_option(parser)
      boolean_verbose_option(parser)

      parser.separator ""
      parser.separator "Common options:"
      # No argument, shows at tail.  This will print an options summary.
      # Try it and see!
      parser.on_tail("-h", "--help", "Show this message") do
        puts parser
        exit
      end
      # Another typical switch to print the version.
      parser.on_tail("--version", "Show version") do
        puts Version
        exit
      end
    end

    def perform_inplace_option(parser)
      # Specifies an optional option argument
      parser.on("-i", "--inplace [EXTENSION]",
                "Edit ARGV files in place",
                "(make backup if EXTENSION supplied)") do |ext|
        self.inplace = true
        self.extension = ext || ''
        self.extension.sub!(/\A\.?(?=.)/, ".")  # Ensure extension begins with dot.
      end
    end

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

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

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

    def list_example_option(parser)
      # List of arguments.
      parser.on("--list x,y,z", Array, "Example 'list' of arguments") do |list|
        self.list = list
      end
    end

    def specify_encoding_option(parser)
      # 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(', ')
      parser.on("--code CODE", CODES, CODE_ALIASES, "Select encoding",
                "(#{code_list})") do |encoding|
        self.encoding = encoding
      end
    end

    def optional_option_argument_with_keyword_completion_option(parser)
      # Optional '--type' option argument with keyword completion.
      parser.on("--type [TYPE]", [:text, :binary, :auto],
                "Select transfer type (text, binary, auto)") do |t|
        self.transfer_type = t
      end
    end

    def boolean_verbose_option(parser)
      # Boolean switch.
      parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
        self.verbose = v
      end
    end
  end

  #
  # Return a structure describing the options.
  #
  def parse(args)
    # The options specified on the command line will be collected in
    # *options*.

    @options = ScriptOptions.new
    @args = OptionParser.new do |parser|
      @options.define_options(parser)
      parser.parse!(args)
    end
    @options
  end

  attr_reader :parser, :options
end  # class OptparseExample

example = OptparseExample.new
options = example.parse(ARGV)
pp options # example.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, along with the accompanying Tutorial, should be enough to learn how to use this class. If you have any questions, file a ticket at bugs.ruby-lang.org.

Constant Summary

ArgumentStyle = Internal use only

Enumeration of acceptable argument styles. Possible values are:

NO_ARGUMENT

The switch takes no arguments. (:NONE)

REQUIRED_ARGUMENT

The switch requires an argument. (:REQUIRED)

OPTIONAL_ARGUMENT

The switch requires an optional argument. (:OPTIONAL)

Use like –switch=argument (long style) or -Xargument (short style). For short style, only portion matched to argument pattern is treated as argument.

# File 'lib/optparse.rb', line 1021
```
{}
```

COMPSYS_HEADER = Internal use only
# File 'lib/optparse.rb', line 1036

<<'XXX'      # :nodoc:

typeset -A opt_args
local context state line

_argume

DecimalInteger =

Decimal integer format, to be converted to Integer.

# File 'lib/optparse.rb', line 2117
```
/\A[-+]?#{decimal}\z/io
```
DecimalNumeric =

Decimal integer/float number format, to be converted to Integer for integer format, Float for float format.

# File 'lib/optparse.rb', line 2143
```
floatpat
```
DefaultList = Internal use only

Switches common used such as ‘–’, and also provides default argument classes

# File 'lib/optparse.rb', line 1031
```
List.new
```
NoArgument = Internal use only
# File 'lib/optparse.rb', line 431
```
[NO_ARGUMENT = :NONE, nil].freeze
```
OctalInteger =

Ruby/C like octal/hexadecimal/binary integer format, to be converted to Integer.

# File 'lib/optparse.rb', line 2130
```
/\A[-]?(?:[0-7](?:_[0-7]+)*|0(?:#{binary}|#{hex}))\z/io
```
Officious = Internal use only

Default options for ::ARGV, which never appear in option summary.

# File 'lib/optparse.rb', line 1076
```
{}
```
OptionalArgument = Internal use only
# File 'lib/optparse.rb', line 433
```
[OPTIONAL_ARGUMENT = :OPTIONAL, false].freeze
```
RequiredArgument = Internal use only
# File 'lib/optparse.rb', line 432
```
[REQUIRED_ARGUMENT = :REQUIRED, true].freeze
```
SPLAT_PROC = Internal use only
# File 'lib/optparse.rb', line 1455
```
proc {|*a| a.length <= 1 ? a.first : a}
```
Version =

The version string

# File 'lib/optparse.rb', line 428
```
"0.6.0"
```

Class Method Summary

.accept(*args, &blk)

See #accept.
.getopts(*args, symbolize_names: false)

See #getopts.
.inc(arg, default = nil)

Returns an incremented value of default according to arg.
.new(banner = nil, width = 32, indent = ' ' * 4) {|_self| ... } ⇒ OptionParser constructor

Initializes the instance and yields itself if called with a block.
.reject(*args, &blk)

See #reject.
.show_version(*pkgs)

Shows version string in packages if Version is defined.
.terminate(arg = nil)

See #terminate.
.top

Returns the global top option list.
.with(*args, &block)

Initializes a new instance and evaluates the optional block in context of the instance.
.each_const(path, base = ::Object) Internal use only
.search_const(klass, name) Internal use only

Instance Attribute Summary

#banner rw

Heading banner preceding summary.
#banner=(value) (also: #set_banner) rw

Heading banner preceding summary.
#default_argv rw

Strings to be parsed in default.
#program_name rw

Program name to be emitted in error message and default banner, defaults to $0.
#program_name=(value) (also: #set_program_name) rw

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

Whether to raise at unknown option.
#release rw

Release code.
#release=(value) rw

Release code.
#require_exact rw

Whether to require that options match exactly (disallows providing abbreviated long option as short option).
#summary_indent rw

Indentation for summary.
#summary_width rw

Width for option list portion of summary.
#version rw

Version.
#version=(value) rw

Version.

Instance Method Summary

#abort(mesg = $!)

Shows message with the program name then aborts.
#accept(*args, &blk)

Directs to accept specified class t.
#additional_message(typ, opt)

Returns additional info.
#base

Subject of #on_tail.
#candidate(word)

Return candidates for word.
#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(*params, &block) (also: #def_option)
#define_by_keywords(options, method, **params)
#define_head(*params, &block) (also: #def_head_option)
#define_tail(*params, &block) (also: #def_tail_option)
#environment(env = File.basename($0, '.*'), **keywords)

Parses environment variable env or its uppercase with splitting like a shell.
#getopts(*args, symbolize_names: false, **keywords)

Wrapper method for getopts.rb.
#help (also: #to_s)

Returns option summary string.
#inc(*args)

See self.inc.
#load(filename = nil, **keywords)

Loads options from file names as filename.
#make_switch(params, block = nil)
#new

Pushes a new List.
#on(*params, &block)
#on_head(*params, &block)
#on_tail(*params, &block)
#order(*argv, **keywords, &nonopt)

Parses command line arguments argv in order.
#order!(argv = default_argv, into: nil, **keywords, &nonopt)

Same as #order, but removes switches destructively.
#parse(*argv, **keywords)

Parses command line arguments argv in order when environment variable POSIXLY_CORRECT is set, and in permutation mode otherwise.
#parse!(argv = default_argv, **keywords)

Same as #parse, but removes switches destructively.
#permute(*argv, **keywords)

Parses command line arguments argv in permutation mode and returns list of non-option arguments.
#permute!(argv = default_argv, **keywords)

Same as #permute, but removes switches destructively.
#reject(*args, &blk)

Directs to reject specified class argument.
#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.
#terminate(arg = nil)

Terminates option parsing.
#to_a

Returns option summary list.
#to_s

Alias for #help.
#top

Subject of #on / #on_head, #accept / #reject
#ver

Returns version string from program_name, version and release.
#warn(mesg = $!)

Shows warning message with the program name.
#add_officious Internal use only
#compsys(to, name = File.basename($0)) Internal use only
#help_exit Internal use only
#inspect Internal use only
#pretty_print(q) Internal use only
#callback!(cb, max_arity, *args) private Internal use only

Calls callback with val.
#complete(typ, opt, icase = false, *pat) private Internal use only

Completes shortened long style option switch and returns pair of canonical switch and switch descriptor Switch.
#notwice(obj, prv, msg) private Internal use only

Checks if an argument is given twice, in which case an ArgumentError is raised.
#parse_in_order(argv = default_argv, setter = nil, exact: require_exact, &nonopt) private Internal use only
#search(id, key) private Internal use only

Searches key in @stack for id hash and returns or yields the result.
#visit(id, *args, &block) private Internal use only

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

Constructor Details

.new(banner = nil, width = 32, indent = ' ' * 4) {|_self| ... } ⇒ `OptionParser`

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

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

Yields:

(_self)

Yield Parameters:

_self (OptionParser) —

the object that the method was called on

[ GitHub ]

# File 'lib/optparse.rb', line 1178


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
  @require_exact = false
  @raise_unknown = true
  add_officious
  yield self if block_given?
end

Class Method Details

.accept(*args, &blk)

See #accept.

[ GitHub ]

# File 'lib/optparse.rb', line 1233


def self.accept(*args, &blk) top.accept(*args, &blk) end

.each_const(path, base = ::Object)

This method is for internal use only.

[ GitHub ]

# File 'lib/optparse/version.rb', line 57


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, symbolize_names: false)

See #getopts.

[ GitHub ]

# File 'lib/optparse.rb', line 1913


def self.getopts(*args, symbolize_names: false)
  new.getopts(*args, symbolize_names: symbolize_names)
end

.inc(arg, default = nil)

Returns an incremented value of default according to arg.

[ GitHub ]

# File 'lib/optparse.rb', line 1155


def self.inc(arg, default = nil)
  case arg
  when Integer
    arg.nonzero?
  when nil
    default.to_i + 1
  end
end

.reject(*args, &blk)

See #reject.

[ GitHub ]

# File 'lib/optparse.rb', line 1246


def self.reject(*args, &blk) top.reject(*args, &blk) end

.search_const(klass, name)

This method is for internal use only.

[ GitHub ]

# File 'lib/optparse/version.rb', line 67


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)

Shows version string in packages if Version is defined.

pkgs: package list

[ GitHub ]

# File 'lib/optparse/version.rb', line 10


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)

See #terminate.

[ GitHub ]

# File 'lib/optparse.rb', line 1208


def self.terminate(arg = nil)
  throw :terminate, arg
end

.top

Returns the global top option list.

Do not use directly.

[ GitHub ]

# File 'lib/optparse.rb', line 1218


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.

[ GitHub ]

# File 'lib/optparse.rb', line 1146


def self.with(*args, &block)
  opts = new(*args)
  opts.instance_eval(&block)
  opts
end

Instance Attribute Details

#default_argv (rw)

Strings to be parsed in default.

[ GitHub ]

# File 'lib/optparse.rb', line 1266


attr_accessor :default_argv

#program_name (rw)

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

[ GitHub ]

# File 'lib/optparse.rb', line 1290


def program_name
  @program_name || File.basename($0, '.*')
end

#program_name=(value) (rw) Also known as: #set_program_name

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

[ GitHub ]

# File 'lib/optparse.rb', line 1257


attr_writer :program_name

#raise_unknown (rw)

Whether to raise at unknown option.

[ GitHub ]

# File 'lib/optparse.rb', line 1273


attr_accessor :raise_unknown

#release (rw)

Release code

[ GitHub ]

# File 'lib/optparse.rb', line 1315


def release
  (defined?(@release) && @release) || (defined?(::Release) && ::Release) || (defined?(::RELEASE) && ::RELEASE)
end

#release=(value) (rw)

Release code

[ GitHub ]

# File 'lib/optparse.rb', line 1303


attr_writer :release

#require_exact (rw)

Whether to require that options match exactly (disallows providing abbreviated long option as short option).

[ GitHub ]

# File 'lib/optparse.rb', line 1270


attr_accessor :require_exact

#summary_indent (rw)

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

[ GitHub ]

# File 'lib/optparse.rb', line 1263


attr_accessor :summary_indent

#summary_width (rw)

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

[ GitHub ]

# File 'lib/optparse.rb', line 1260


attr_accessor :summary_width

#version (rw)

Version

[ GitHub ]

# File 'lib/optparse.rb', line 1308


def version
  (defined?(@version) && @version) || (defined?(::Version) && ::Version)
end

#version=(value) (rw)

Version

[ GitHub ]

# File 'lib/optparse.rb', line 1301


attr_writer :version

Instance Method Details

#abort(mesg = $!)

Shows message with the program name then aborts.

mesg: Message, defaulted to $!.

See Kernel.abort.

[ GitHub ]

# File 'lib/optparse.rb', line 1348


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)

[ GitHub ]

# File 'lib/optparse.rb', line 1229


def accept(*args, &blk) top.accept(*args, &blk) end

#add_officious

This method is for internal use only.

[ GitHub ]

# File 'lib/optparse.rb', line 1191


def add_officious  # :nodoc:
  list = base()
  Officious.each do |opt, block|
    list.long[opt] ||= block.call(self)
  end
end

#additional_message(typ, opt)

Returns additional info.

[ GitHub ]

# File 'lib/optparse.rb', line 1964


def additional_message(typ, opt)
  return unless typ and opt and defined?(DidYouMean::SpellChecker)
  all_candidates = []
  visit(:get_candidates, typ) do |candidates|
    all_candidates.concat(candidates)
  end
  all_candidates.select! {|cand| cand.is_a?(String) }
  checker = DidYouMean::SpellChecker.new(dictionary: all_candidates)
  DidYouMean.formatter.message_for(all_candidates & checker.correct(opt))
end

#base

Subject of #on_tail.

[ GitHub ]

# File 'lib/optparse.rb', line 1362


def base
  @stack[1]
end

#callback!(cb, max_arity, *args) (private)

This method is for internal use only.

Calls callback with val.

[ GitHub ]

# File 'lib/optparse.rb', line 1800


def callback!(cb, max_arity, *args) # :nodoc:
  args.compact!

  if (size = args.size) < max_arity and cb.to_proc.lambda?
    (arity = cb.arity) < 0 and arity = (1-arity)
    arity = max_arity if arity > max_arity
    args[arity - 1] = nil if arity > size
  end
  cb.call(*args)
end

#candidate(word)

Return candidates for word.

[ GitHub ]

# File 'lib/optparse.rb', line 1978


def candidate(word)
  list = []
  case word
  when '-'
    long = short = true
  when /\A--/
    word, arg = word.split(/=/, 2)
    argpat = Completion.regexp(arg, false) if arg and !arg.empty?
    long = true
  when /\A-/
    short = true
  end
  pat = Completion.regexp(word, long)
  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

#complete(typ, opt, icase = false, *pat) (private)

This method is for internal use only.

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

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

Raises:

(exc)

[ GitHub ]

# File 'lib/optparse.rb', line 1949


def complete(typ, opt, icase = false, *pat) # :nodoc:
  if pat.empty?
    search(typ, opt) {|sw| return [sw, opt]} # exact match or...
  end
  ambiguous = catch(:ambiguous) {
    visit(:complete, typ, opt, icase, *pat) {|o, *sw| return sw}
  }
  exc = ambiguous ? AmbiguousOption : InvalidOption
  raise exc.new(opt, additional: self.method(:additional_message).curry[typ])
end

#compsys(to, name = File.basename($0))

This method is for internal use only.

[ GitHub ]

# File 'lib/optparse.rb', line 1044


def compsys(to, name = File.basename($0)) # :nodoc:
  to << "#compdef #{name}\n"
  to << COMPSYS_HEADER
  visit(:compsys, {}, {}) {|o, d|
    to << %Q[  "#{o}[#{d.gsub(/[\\\"\[\]]/, '\\\\\&')}]" \\\n]
  }
  to << "  '*:file:_files' && return 0\n"
end

#def_head_option(*opts, &block)

Alias for #define_head.

[ GitHub ]

# File 'lib/optparse.rb', line 1643


alias def_head_option define_head

#def_option(*opts, &block)

Alias for #define.

[ GitHub ]

# File 'lib/optparse.rb', line 1620


alias def_option define

#def_tail_option(*opts, &block)

Alias for #define_tail.

[ GitHub ]

# File 'lib/optparse.rb', line 1667


alias def_tail_option define_tail

#define(*params, &block) Also known as: #def_option

[ GitHub ]

# File 'lib/optparse.rb', line 1606


def define(*opts, &block)
  top.append(*(sw = make_switch(opts, block)))
  sw[0]
end

#define_by_keywords(options, method, **params)

Defines options which set in to options for keyword parameters of method.

Parameters for each keywords are given as elements of params.

[ GitHub ]

# File 'lib/optparse/kwargs.rb', line 15


def define_by_keywords(options, method, **params)
  method.parameters.each do |type, name|
    case type
    when :key, :keyreq
      op, cl = *(type == :key ? %w"[ ]" : ["", ""])
      define("--#{name}=#{op}#{name.upcase}#{cl}", *params[name]) do |o|
        options[name] = o
      end
    end
  end
  options
end

#define_head(*params, &block) Also known as: #def_head_option

[ GitHub ]

# File 'lib/optparse.rb', line 1627


def define_head(*opts, &block)
  top.prepend(*(sw = make_switch(opts, block)))
  sw[0]
end

#define_tail(*params, &block) Also known as: #def_tail_option

[ GitHub ]

# File 'lib/optparse.rb', line 1650


def define_tail(*opts, &block)
  base.append(*(sw = make_switch(opts, block)))
  sw[0]
end

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

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

env defaults to the basename of the program.

[ GitHub ]

# File 'lib/optparse.rb', line 2051


def environment(env = File.basename($0, '.*'), **keywords)
  env = ENV[env] || ENV[env.upcase] or return
  require 'shellwords'
  parse(*Shellwords.shellwords(env), **keywords)
end

#getopts(*args, symbolize_names: false, **keywords)

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

Option symbolize_names (boolean) specifies whether returned Hash keys should be Symbols; defaults to false (use Strings).

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

[ GitHub ]

# File 'lib/optparse.rb', line 1878


def getopts(*args, symbolize_names: false, **keywords)
  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(:[]=), **keywords)
  symbolize_names ? result.transform_keys(&:to_sym) : result
end

#help Also known as: #to_s

Returns option summary string.

[ GitHub ]

# File 'lib/optparse.rb', line 1407


def help; summarize("#{banner}".sub(/\n?\z/, "\n")) end

#help_exit

This method is for internal use only.

[ GitHub ]

# File 'lib/optparse.rb', line 1053


def help_exit
  if STDOUT.tty? && (pager = ENV.values_at(*%w[RUBY_PAGER PAGER]).find {|e| e && !e.empty?})
    less = ENV["LESS"]
    args = [{"LESS" => "#{!less || less.empty? ? '-' : less}Fe"}, pager, "w"]
    print = proc do |f|
      f.puts help
    rescue Errno::EPIPE
      # pager terminated
    end
    if Process.respond_to?(:fork) and false
      IO.popen("-") {|f| f ? Process.exec(*args, in: f) : print.call(STDOUT)}
      # unreachable
    end
    IO.popen(*args, &print)
  else
    puts help
  end
  exit
end

#inc(*args)

See self.inc

[ GitHub ]

# File 'lib/optparse.rb', line 1167


def inc(*args)
  self.class.inc(*args)
end

#inspect

This method is for internal use only.

[ GitHub ]

# File 'lib/optparse.rb', line 1428


def inspect                   # :nodoc:
  require 'pp'
  pretty_print_inspect
end

#load(filename = nil, **keywords)

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, then the basename with ‘.options’ suffix under XDG and Haiku standard places.

The optional into keyword argument works exactly like that accepted in method #parse.

[ GitHub ]

# File 'lib/optparse.rb', line 2019


def load(filename = nil, **keywords)
  unless filename
    basename = File.basename($0, '.*')
    return true if load(File.expand_path(basename, '~/.options'), **keywords) rescue nil
    basename << ".options"
    return [
      # XDG
      ENV['XDG_CONFIG_HOME'],
      '~/.config',
      *ENV['XDG_CONFIG_DIRS']&.split(File::PATH_SEPARATOR),

      # Haiku
      '~/config/settings',
    ].any? {|dir|
      next if !dir or dir.empty?
      load(File.expand_path(basename, dir), **keywords) rescue nil
    }
  end
  begin
    parse(*File.readlines(filename, chomp: true), **keywords)
    true
  rescue Errno::ENOENT, Errno::ENOTDIR
    false
  end
end

#make_switch(params, block = nil)

[ GitHub ]

# File 'lib/optparse.rb', line 1462


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}"
      (q = q.downcase).tr!('_', '-')
      long << "no-#{q}"
      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}"
      (o = q.downcase).tr!('_', '-')
      long << o
      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}"
      (o = q.downcase).tr!('_', '-')
      long << o
    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) if o && !o.empty?
    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

#new

Pushes a new ::OptionParser::List.

If a block is given, yields self and returns the result of the block, otherwise returns self.

[ GitHub ]

# File 'lib/optparse.rb', line 1372


def new
  @stack.push(List.new)
  if block_given?
    yield self
  else
    self
  end
end

#notwice(obj, prv, msg) (private)

This method is for internal use only.

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.

[ GitHub ]

# File 'lib/optparse.rb', line 1446


def notwice(obj, prv, msg) # :nodoc:
  unless !prv or prv == obj
    raise(ArgumentError, "argument #{msg} given twice: #{obj}",
          ParseError.filter_backtrace(caller(2)))
  end
  obj
end

#on(*params, &block)

[ GitHub ]

# File 'lib/optparse.rb', line 1616


def on(*opts, &block)
  define(*opts, &block)
  self
end

#on_head(*params, &block)

The new option is added at the head of the summary.

[ GitHub ]

# File 'lib/optparse.rb', line 1639


def on_head(*opts, &block)
  define_head(*opts, &block)
  self
end

#on_tail(*params, &block)

The new option is added at the tail of the summary.

[ GitHub ]

# File 'lib/optparse.rb', line 1663


def on_tail(*opts, &block)
  define_tail(*opts, &block)
  self
end

#order(*argv, **keywords, &nonopt)

Parses command line arguments argv in order. When a block is given, each non-option argument is yielded. When optional into keyword argument is provided, the parsed option values are stored there via []= method (so it can be Hash, or OpenStruct, or other similar object).

Returns the rest of argv left unparsed.

[ GitHub ]

# File 'lib/optparse.rb', line 1692


def order(*argv, **keywords, &nonopt)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  order!(argv, **keywords, &nonopt)
end

#order!(argv = default_argv, into: nil, **keywords, &nonopt)

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

[ GitHub ]

# File 'lib/optparse.rb', line 1701


def order!(argv = default_argv, into: nil, **keywords, &nonopt)
  setter = ->(name, val) {into[name.to_sym] = val} if into
  parse_in_order(argv, setter, **keywords, &nonopt)
end

#parse(*argv, **keywords)

Parses command line arguments argv in order when environment variable POSIXLY_CORRECT is set, and in permutation mode otherwise. When optional into keyword argument is provided, the parsed option values are stored there via []= method (so it can be Hash, or OpenStruct, or other similar object).

[ GitHub ]

# File 'lib/optparse.rb', line 1842


def parse(*argv, **keywords)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  parse!(argv, **keywords)
end

#parse!(argv = default_argv, **keywords)

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

[ GitHub ]

# File 'lib/optparse.rb', line 1851


def parse!(argv = default_argv, **keywords)
  if ENV.include?('POSIXLY_CORRECT')
    order!(argv, **keywords)
  else
    permute!(argv, **keywords)
  end
end

#parse_in_order(argv = default_argv, setter = nil, exact: require_exact, &nonopt) (private)

This method is for internal use only.

[ GitHub ]

# File 'lib/optparse.rb', line 1706


def parse_in_order(argv = default_argv, setter = nil, exact: require_exact, **, &nonopt)  # :nodoc:
  opt, arg, val, rest = nil
  nonopt ||= proc {|a| throw :terminate, a}
  argv.unshift(arg) if arg = catch(:terminate) {
    while arg = argv.shift
      case arg
      # long option
      when /\A--([^=]*)(?:=(.*))?/m
        opt, rest = $1, $2
        opt.tr!('_', '-')
        begin
          if exact
            sw, = search(:long, opt)
          else
            sw, = complete(:long, opt, true)
          end
        rescue ParseError
          throw :terminate, arg unless raise_unknown
          raise $!.set_option(arg, true)
        else
          unless sw
            throw :terminate, arg unless raise_unknown
            raise InvalidOption, arg
          end
        end
        begin
          opt, cb, val = sw.parse(rest, argv) {|*exc| raise(*exc)}
          val = callback!(cb, 1, val) if cb
          callback!(setter, 2, sw.switch_name, val) if setter
        rescue ParseError
          raise $!.set_option(arg, rest)
        end

      # short option
      when /\A-(.)((=).*|.+)?/m
        eq, rest, opt = $3, $2, $1
        has_arg, val = eq, rest
        begin
          sw, = search(:short, opt)
          unless sw
            begin
              sw, = complete(:short, opt)
              # short option matched.
              val = arg.delete_prefix('-')
              has_arg = true
            rescue InvalidOption
              raise if exact
              # if no short options match, try completion with long
              # options.
              sw, = complete(:long, opt)
              eq ||= !rest
            end
          end
        rescue ParseError
          throw :terminate, arg unless raise_unknown
          raise $!.set_option(arg, true)
        end
        begin
          opt, cb, val = sw.parse(val, argv) {|*exc| raise(*exc) if eq}
        rescue ParseError
          raise $!.set_option(arg, arg.length > 2)
        else
          raise InvalidOption, arg if has_arg and !eq and arg == "-#{opt}"
        end
        begin
          argv.unshift(opt) if opt and (!rest or (opt = opt.sub(/\A-*/, '-')) != '-')
          val = callback!(cb, 1, val) if cb
          callback!(setter, 2, sw.switch_name, val) if setter
        rescue ParseError
          raise $!.set_option(arg, arg.length > 2)
        end

      # non-option argument
      else
        catch(:prune) do
          visit(:each_option) do |sw0|
            sw = sw0
            sw.block.call(arg) if Switch === sw and sw.match_nonswitch?(arg)
          end
          nonopt.call(arg)
        end
      end
    end

    nil
  }

  visit(:search, :short, nil) {|sw| sw.block.call(*argv) if !sw.pattern}

  argv
end

#permute(*argv, **keywords)

Parses command line arguments argv in permutation mode and returns list of non-option arguments. When optional into keyword argument is provided, the parsed option values are stored there via []= method (so it can be Hash, or OpenStruct, or other similar object).

[ GitHub ]

# File 'lib/optparse.rb', line 1819


def permute(*argv, **keywords)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  permute!(argv, **keywords)
end

#permute!(argv = default_argv, **keywords)

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

[ GitHub ]

# File 'lib/optparse.rb', line 1828


def permute!(argv = default_argv, **keywords)
  nonopts = []
  order!(argv, **keywords, &nonopts.method(:<<))
  argv[0, 0] = nonopts
  argv
end

#pretty_print(q)

This method is for internal use only.

[ GitHub ]

# File 'lib/optparse.rb', line 1410


def pretty_print(q)           # :nodoc:
  q.object_group(self) do
    first = true
    if @stack.size > 2
      @stack.each_with_index do |s, i|
        next if i < 2
        next if s.list.empty?
        if first
          first = false
          q.text ":"
        end
        q.breakable
        s.pretty_print(q)
      end
    end
  end
end

#reject(*args, &blk)

Directs to reject specified class argument.

type: Argument class specifier, any object including Class.

reject(type)

[ GitHub ]

# File 'lib/optparse.rb', line 1242


def reject(*args, &blk) top.reject(*args, &blk) end

#remove

Removes the last ::OptionParser::List.

[ GitHub ]

# File 'lib/optparse.rb', line 1384


def remove
  @stack.pop
end

#search(id, key) (private)

This method is for internal use only.

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

[ GitHub ]

# File 'lib/optparse.rb', line 1932


def search(id, key) # :nodoc:
  block_given = block_given?
  visit(:search, id, key) do |k|
    return block_given ? yield(k) : k
  end
end

#separator(string)

Add separator in summary.

[ GitHub ]

# File 'lib/optparse.rb', line 1672


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.

[ GitHub ]

# File 'lib/optparse.rb', line 1397


def summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk)
  nl = "\n"
  blk ||= proc {|l| to << (l.index(nl, -1) ? l : l + nl)}
  visit(:summarize, {}, {}, width, max, indent, &blk)
  to
end

#terminate(arg = nil)

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

[ GitHub ]

# File 'lib/optparse.rb', line 1202


def terminate(arg = nil)
  self.class.terminate(arg)
end

#to_a

Returns option summary list.

[ GitHub ]

# File 'lib/optparse.rb', line 1436


def to_a; summarize("#{banner}".split(/^/)) end

#to_s

Alias for #help.

[ GitHub ]

# File 'lib/optparse.rb', line 1408


alias to_s help

#top

Subject of #on / #on_head, #accept / #reject

[ GitHub ]

# File 'lib/optparse.rb', line 1355


def top
  @stack[-1]
end

#ver

Returns version string from program_name, version and release.

[ GitHub ]

# File 'lib/optparse.rb', line 1322


def ver
  if v = version
    str = +"#{program_name} #{[v].join('.')}"
    str << " (#{v})" if v = release
    str
  end
end

#visit(id, *args, &block) (private)

This method is for internal use only.

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

[ GitHub ]

# File 'lib/optparse.rb', line 1921


def visit(id, *args, &block) # :nodoc:
  @stack.reverse_each do |el|
    el.__send__(id, *args, &block)
  end
  nil
end

#warn(mesg = $!)

Shows warning message with the program name

mesg: Message, defaulted to $!.

See Kernel.warn.

[ GitHub ]

# File 'lib/optparse.rb', line 1337


def warn(mesg = $!)
  super("#{program_name}: #{mesg}")
end

Class: OptionParser

Overview

New to OptionParser?

Introduction

Features

Minimal example

Generating Help

Required Arguments

Type Coercion

Using Built-in Conversions

Creating Custom Conversions

Store options to a Hash

Complete example

Shell Completion

Further documentation

Constant Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(banner = nil, width = 32, indent = ' ' * 4) {|_self| ... } ⇒ OptionParser

Class Method Details

.accept(*args, &blk)

.each_const(path, base = ::Object)

.getopts(*args, symbolize_names: false)

.inc(arg, default = nil)

.reject(*args, &blk)

.search_const(klass, name)

.show_version(*pkgs)

.terminate(arg = nil)

.top

.with(*args, &block)

Instance Attribute Details

#banner (rw)

#banner=(value) (rw) Also known as: #set_banner

#default_argv (rw)

#program_name (rw)

#program_name=(value) (rw) Also known as: #set_program_name

#raise_unknown (rw)

#release (rw)

#release=(value) (rw)

#require_exact (rw)

#summary_indent (rw)

#summary_width (rw)

#version (rw)

#version=(value) (rw)

Instance Method Details

#abort(mesg = $!)

#accept(*args, &blk)

#add_officious

#additional_message(typ, opt)

#base

#callback!(cb, max_arity, *args) (private)

#candidate(word)

#complete(typ, opt, icase = false, *pat) (private)

#compsys(to, name = File.basename($0))

#def_head_option(*opts, &block)

#def_option(*opts, &block)

#def_tail_option(*opts, &block)

#define(*params, &block) Also known as: #def_option

#define_by_keywords(options, method, **params)

#define_head(*params, &block) Also known as: #def_head_option

#define_tail(*params, &block) Also known as: #def_tail_option

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

#getopts(*args, symbolize_names: false, **keywords)

#help Also known as: #to_s

#help_exit

#inc(*args)

#inspect

#load(filename = nil, **keywords)

#make_switch(params, block = nil)

#new

#notwice(obj, prv, msg) (private)

#on(*params, &block)

#on_head(*params, &block)

#on_tail(*params, &block)

#order(*argv, **keywords, &nonopt)

#order!(argv = default_argv, into: nil, **keywords, &nonopt)

#parse(*argv, **keywords)

#parse!(argv = default_argv, **keywords)

New to `OptionParser`?

.new(banner = nil, width = 32, indent = ' ' * 4) {|_self| ... } ⇒ `OptionParser`