Class: OptionParser

Inherits:
Object
  • Object
show all
Defined in:
lib/optparse.rb

Overview

–

Developer Documentation (not for RDoc output)

Class tree

  • OptionParser

    front end

  • OptionParser::Switch

    each switches

  • OptionParser::List

    options list

  • OptionParser::ParseError

    errors on parsing

    • OptionParser::AmbiguousOption

    • OptionParser::NeedlessArgument

    • OptionParser::MissingArgument

    • OptionParser::InvalidOption

    • OptionParser::InvalidArgument

      • OptionParser::AmbiguousArgument

Object relationship diagram

+--------------+
| OptionParser |<>-----+
+--------------+       |                      +--------+
                       |                    ,-| Switch |
     on_head -------->+---------------+    /  +--------+
     accept/reject -->| List          |<|>-
                      |               |<|>-  +----------+
     on ------------->+---------------+    `-| argument |
                        :           :        |  class   |
                      +---------------+      |==========|
     on_tail -------->|               |      |pattern   |
                      +---------------+      |----------|
OptionParser.accept ->| DefaultList   |      |converter |
             reject   |(shared between|      +----------+
                      | all instances)|
                      +---------------+

++

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

  1. The argument specification and the code to handle it are written in the same place.

  2. It can output an option summary; you don’t need to maintain this string separately.

  3. Optional and mandatory arguments are specified very gracefully.

  4. Arguments can be automatically converted to a specified class.

  5. 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

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

  • DateTime – Anything accepted by DateTime.parse

  • Time – Anything accepted by Time.httpdate or Time.parse

  • URI – Anything accepted by URI.parse

  • Shellwords – Anything accepted by Shellwords.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'

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

p params

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 should be enough to learn how to use this class. If you have any questions, file a ticket at bugs.ruby-lang.org.

Defined Under Namespace

Modules: Acceptables, Arguable, Completion Classes: AmbiguousArgument, AmbiguousOption, CompletingHash, InvalidArgument, InvalidOption, List, MissingArgument, NeedlessArgument, OptionMap, ParseError, Switch

Constant Summary collapse

NoArgument =

:stopdoc:

[NO_ARGUMENT = :NONE, nil].freeze
RequiredArgument = 
[REQUIRED_ARGUMENT = :REQUIRED, true].freeze
OptionalArgument = 
[OPTIONAL_ARGUMENT = :OPTIONAL, false].freeze
ArgumentStyle =

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.

{}
DefaultList =

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

List.new
COMPSYS_HEADER =

:nodoc:

<<'XXX'      # :nodoc:

typeset -A opt_args
local context state line

_argume
Officious =

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

{}
SPLAT_PROC =

:nodoc:

proc {|*a| a.length <= 1 ? a.first : a}
DecimalInteger =

Decimal integer format, to be converted to Integer.

/\A[-+]?#{decimal}\z/io
OctalInteger =

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

/\A[-+]?(?:[0-7]+(?:_[0-7]+)*|0(?:#{binary}|#{hex}))\z/io
DecimalNumeric =

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

floatpat

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(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



1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
 
# File 'lib/optparse.rb', line 1085

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

Instance Attribute Details

Heading banner preceding summary.



1168
1169
1170
1171
1172
1173
1174
 
# File 'lib/optparse.rb', line 1168

def banner
  unless @banner
    @banner = +"Usage: #{program_name} [options]"
    visit(:add_banner, @banner)
  end
  @banner
end

#default_argv ⇒ Object

Strings to be parsed in default.



1163
1164
1165
 
# File 'lib/optparse.rb', line 1163

def default_argv
  @default_argv
end

#program_name ⇒ Object

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



1180
1181
1182
 
# File 'lib/optparse.rb', line 1180

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

#release ⇒ Object

Release code



1205
1206
1207
 
# File 'lib/optparse.rb', line 1205

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

#summary_indent ⇒ Object

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



1160
1161
1162
 
# File 'lib/optparse.rb', line 1160

def summary_indent
  @summary_indent
end

#summary_width ⇒ Object

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



1157
1158
1159
 
# File 'lib/optparse.rb', line 1157

def summary_width
  @summary_width
end

#version ⇒ Object

Version



1198
1199
1200
 
# File 'lib/optparse.rb', line 1198

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

Class Method Details

.accept(*args, &blk) ⇒ Object

See #accept.



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

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

.getopts(*args) ⇒ Object

See #getopts.



1740
1741
1742
 
# File 'lib/optparse.rb', line 1740

def self.getopts(*args)
  new.getopts(*args)
end

.inc(arg, default = nil) ⇒ Object

Returns an incremented value of default according to arg.



1066
1067
1068
1069
1070
1071
1072
1073
 
# File 'lib/optparse.rb', line 1066

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

.reject(*args, &blk) ⇒ Object

See #reject.



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

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

.terminate(arg = nil) ⇒ Object 



1110
1111
1112
 
# File 'lib/optparse.rb', line 1110

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

.top ⇒ Object 



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

def self.top() DefaultList end

.with(*args, &block) ⇒ Object

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.



1057
1058
1059
1060
1061
 
# File 'lib/optparse.rb', line 1057

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

Instance Method Details

#abort(mesg = $!) ⇒ Object 



1224
1225
1226
 
# File 'lib/optparse.rb', line 1224

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

#accept(*args, &blk) ⇒ Object

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)



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

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

#add_officious ⇒ Object

:nodoc:



1096
1097
1098
1099
1100
1101
 
# File 'lib/optparse.rb', line 1096

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

#additional_message(typ, opt) ⇒ Object

Returns additional info.



1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
 
# File 'lib/optparse.rb', line 1791

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 ⇒ Object

Subject of #on_tail.



1238
1239
1240
 
# File 'lib/optparse.rb', line 1238

def base
  @stack[1]
end

#candidate(word) ⇒ Object 



1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
 
# File 'lib/optparse.rb', line 1802

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

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

:nodoc:



974
975
976
977
978
979
980
981
 
# File 'lib/optparse.rb', line 974

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

#define(*opts, &block) ⇒ Object Also known as: def_option 



1499
1500
1501
1502
 
# File 'lib/optparse.rb', line 1499

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

#define_head(*opts, &block) ⇒ Object Also known as: def_head_option 



1514
1515
1516
1517
 
# File 'lib/optparse.rb', line 1514

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

#define_tail(*opts, &block) ⇒ Object Also known as: def_tail_option 



1528
1529
1530
1531
 
# File 'lib/optparse.rb', line 1528

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

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

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

env defaults to the basename of the program.



1872
1873
1874
1875
1876
 
# File 'lib/optparse.rb', line 1872

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

#getopts(*args) ⇒ Object

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



1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
 
# File 'lib/optparse.rb', line 1705

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

#help ⇒ Object Also known as: to_s

Returns option summary string.



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

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

#inc(*args) ⇒ Object 



1074
1075
1076
 
# File 'lib/optparse.rb', line 1074

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

#load(filename = nil) ⇒ Object

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.



1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
 
# File 'lib/optparse.rb', line 1840

def load(filename = nil)
  unless filename
    basename = File.basename($0, '.*')
    return true if load(File.expand_path(basename, '~/.options')) 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)) rescue nil
    }
  end
  begin
    parse(*IO.readlines(filename).each {|s| s.chomp!})
    true
  rescue Errno::ENOENT, Errno::ENOTDIR
    false
  end
end

#make_switch(opts, block = nil) ⇒ Object

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 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"

If you give multiple description strings, each string will be printed line by line.

Handler:

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



1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
 
# File 'lib/optparse.rb', line 1366

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)
    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 ⇒ Object

Pushes a new List.



1245
1246
1247
1248
1249
1250
1251
1252
 
# File 'lib/optparse.rb', line 1245

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

#on(*opts, &block) ⇒ Object

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



1508
1509
1510
1511
 
# File 'lib/optparse.rb', line 1508

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

#on_head(*opts, &block) ⇒ Object

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



1522
1523
1524
1525
 
# File 'lib/optparse.rb', line 1522

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

#on_tail(*opts, &block) ⇒ Object

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



1536
1537
1538
1539
 
# File 'lib/optparse.rb', line 1536

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

#order(*argv, into: nil, &nonopt) ⇒ Object

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.



1558
1559
1560
1561
 
# File 'lib/optparse.rb', line 1558

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

#order!(argv = default_argv, into: nil, &nonopt) ⇒ Object

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



1567
1568
1569
1570
 
# File 'lib/optparse.rb', line 1567

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

#parse(*argv, into: nil) ⇒ Object

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).



1678
1679
1680
1681
 
# File 'lib/optparse.rb', line 1678

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

#parse!(argv = default_argv, into: nil) ⇒ Object

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



1687
1688
1689
1690
1691
1692
1693
 
# File 'lib/optparse.rb', line 1687

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

#permute(*argv, into: nil) ⇒ Object

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).



1655
1656
1657
1658
 
# File 'lib/optparse.rb', line 1655

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

#permute!(argv = default_argv, into: nil) ⇒ Object

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



1664
1665
1666
1667
1668
1669
 
# File 'lib/optparse.rb', line 1664

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

#reject(*args, &blk) ⇒ Object

Directs to reject specified class argument.

t

Argument class specifier, any object including Class.

reject(t)



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

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

#remove ⇒ Object

Removes the last List.



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

def remove
  @stack.pop
end

#separator(string) ⇒ Object

Add separator in summary.



1545
1546
1547
 
# File 'lib/optparse.rb', line 1545

def separator(string)
  top.append(string, nil, nil)
end

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

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.



1270
1271
1272
1273
1274
1275
 
# File 'lib/optparse.rb', line 1270

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) ⇒ Object

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



1107
1108
1109
 
# File 'lib/optparse.rb', line 1107

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

#to_a ⇒ Object

Returns option summary list.



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

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

#top ⇒ Object

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



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

def top
  @stack[-1]
end

#ver ⇒ Object

Returns version string from program_name, version and release.



1212
1213
1214
1215
1216
1217
1218
 
# File 'lib/optparse.rb', line 1212

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

#warn(mesg = $!) ⇒ Object 



1220
1221
1222
 
# File 'lib/optparse.rb', line 1220

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