In Files

  • optparse.rb
  • optparse/date.rb
  • optparse/time.rb

OptionParser

Developer Documentation (not for RDoc output)

Class tree

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.

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

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

    opts = 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 OptionParser::Version.join('.')
        exit
      end
    end

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

end  # class OptparseExample

options = OptparseExample.parse(ARGV)
pp options

Further documentation

The above examples should be enough to learn how to use this class. If you have any questions, email me (gsinclair@soyabean.com.au) and I will update this document.

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

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) click to toggle source

See accept.

 
               # File optparse.rb, line 826
def self.accept(*args, &blk) top.accept(*args, &blk) end
            
each_const(path, klass = ::Object) click to toggle source
 
               # File optparse/version.rb, line 49
def each_const(path, klass = ::Object)
  path.split(/::|\//).inject(klass) do |klass, name|
    raise NameError, path unless Module === klass
    klass.constants.grep(/#{name}/i) do |c|
      klass.const_defined?(c) or next
      c = klass.const_get(c)
    end
  end
end
            
getopts(*args) click to toggle source

See getopts.

 
               # File optparse.rb, line 1405
def self.getopts(*args)
  new.getopts(*args)
end
            
inc(arg, default = nil) click to toggle source

Returns an incremented value of default according to arg.

 
               # File optparse.rb, line 762
def self.inc(arg, default = nil)
  case arg
  when Integer
    arg.nonzero?
  when nil
    default.to_i + 1
  end
end
            
new(banner = nil, width = 32, indent = ' ' * 4) click to toggle source

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

banner

Banner message.

width

Summary width.

indent

Summary indent.

 
               # File optparse.rb, line 781
def initialize(banner = nil, width = 32, indent = ' ' * 4)
  @stack = [DefaultList, List.new, List.new]
  @program_name = nil
  @banner = banner
  @summary_width = width
  @summary_indent = indent
  @default_argv = ARGV
  add_officious
  yield self if block_given?
end
            
reject(*args, &blk) click to toggle source

See reject.

 
               # File optparse.rb, line 839
def self.reject(*args, &blk) top.reject(*args, &blk) end
            
search_const(klass, name) click to toggle source
 
               # File 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(*pkg) click to toggle source
 
               # File optparse/version.rb, line 4
def show_version(*pkg)
  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 pkg.size == 1 and pkg[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
    pkg.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) click to toggle source
 
               # File optparse.rb, line 806
def self.terminate(arg = nil)
  throw :terminate, arg
end
            
top() click to toggle source
 
               # File optparse.rb, line 811
def self.top() DefaultList end
            
with(*args, &block) click to toggle source

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.

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

Public Instance Methods

abort(mesg = $!) click to toggle source
 
               # File optparse.rb, line 920
def abort(mesg = $!)
  super("#{program_name}: #{mesg}")
end
            
accept(*args, &blk) click to toggle source

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 optparse.rb, line 822
def accept(*args, &blk) top.accept(*args, &blk) end
            
base() click to toggle source

Subject of on_tail.

 
               # File optparse.rb, line 934
def base
  @stack[1]
end
            
def_head_option(*opts, &block) click to toggle source
Alias for: define_head
def_option(*opts, &block) click to toggle source
Alias for: define
def_tail_option(*opts, &block) click to toggle source
Alias for: define_tail
define(*opts, &block) click to toggle source
 
               # File optparse.rb, line 1181
def define(*opts, &block)
  top.append(*(sw = make_switch(opts, block)))
  sw[0]
end
            
Also aliased as: def_option
define_head(*opts, &block) click to toggle source
 
               # File optparse.rb, line 1196
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) click to toggle source
 
               # File optparse.rb, line 1210
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, '.*')) click to toggle source

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

env defaults to the basename of the program.

 
               # File optparse.rb, line 1480
def environment(env = File.basename($0, '.*'))
  env = ENV[env] || ENV[env.upcase] or return
  require 'shellwords'
  parse(*Shellwords.shellwords(env))
end
            
getopts(*args) click to toggle source

Wrapper method for getopts.rb.

params = ARGV.getopts("ab:", "foo", "bar:")
# params[:a] = true   # -a
# params[:b] = "1"    # -b1
# params[:foo] = "1"  # --foo
# params[:bar] = "x"  # --bar x
 
               # File optparse.rb, line 1371
def getopts(*args)
  argv = Array === args.first ? args.shift : default_argv
  single_options, *long_options = *args

  result = {}

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

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

  parse_in_order(argv, result.method(:[]=))
  result
end
            
help() click to toggle source

Returns option summary string.

 
               # File optparse.rb, line 975
def help; summarize(banner.to_s.sub(/\n?\z/, "\n")) end
            
Also aliased as: to_s
inc(*args) click to toggle source
 
               # File optparse.rb, line 770
def inc(*args)
  self.class.inc(*args)
end
            
load(filename = nil) click to toggle source

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.

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

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 regural expression):

"-[a-z]MANDATORY"
"-[a-z][OPTIONAL]" 
"-[a-z]"
Argument style and description:

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

"=MANDATORY"
"=[OPTIONAL]"
Description:

Description string for the option.

"Run verbosely"
Handler:

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

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

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

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

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

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

Pushes a new List.

 
               # File optparse.rb, line 941
def new
  @stack.push(List.new)
  if block_given?
    yield self
  else
    self
  end
end
            
on(*opts, &block) click to toggle source

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

 
               # File optparse.rb, line 1190
def on(*opts, &block)
  define(*opts, &block)
  self
end
            
on_head(*opts, &block) click to toggle source

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

 
               # File optparse.rb, line 1204
def on_head(*opts, &block)
  define_head(*opts, &block)
  self
end
            
on_tail(*opts, &block) click to toggle source

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

 
               # File optparse.rb, line 1218
def on_tail(*opts, &block)
  define_tail(*opts, &block)
  self
end
            
order(*argv, &block) click to toggle source

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.

 
               # File optparse.rb, line 1237
def order(*argv, &block)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  order!(argv, &block)
end
            
order!(argv = default_argv, &nonopt) click to toggle source

Same as order, but removes switches destructively.

 
               # File optparse.rb, line 1245
def order!(argv = default_argv, &nonopt)
  parse_in_order(argv, &nonopt)
end
            
parse(*argv) click to toggle source

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

 
               # File optparse.rb, line 1346
def parse(*argv)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  parse!(argv)
end
            
parse!(argv = default_argv) click to toggle source

Same as parse, but removes switches destructively.

 
               # File optparse.rb, line 1354
def parse!(argv = default_argv)
  if ENV.include?('POSIXLY_CORRECT')
    order!(argv)
  else
    permute!(argv)
  end
end
            
permute(*argv) click to toggle source

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

 
               # File optparse.rb, line 1326
def permute(*argv)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  permute!(argv)
end
            
permute!(argv = default_argv) click to toggle source

Same as permute, but removes switches destructively.

 
               # File optparse.rb, line 1334
def permute!(argv = default_argv)
  nonopts = []
  arg = nil
  order!(argv) {|arg| nonopts << arg}
  argv[0, 0] = nonopts
  argv
end
            
program_name() click to toggle source

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

 
               # File optparse.rb, line 876
def program_name
  @program_name || File.basename($0, '.*')
end
            
reject(*args, &blk) click to toggle source

Directs to reject specified class argument.

t

Argument class speficier, any object including Class.

reject(t)
 
               # File optparse.rb, line 835
def reject(*args, &blk) top.reject(*args, &blk) end
            
release() click to toggle source

Release code

 
               # File optparse.rb, line 901
def release
  @release || (defined?(::Release) && ::Release) || (defined?(::RELEASE) && ::RELEASE)
end
            
remove() click to toggle source

Removes the last List.

 
               # File optparse.rb, line 953
def remove
  @stack.pop
end
            
separator(string) click to toggle source

Add separator in summary.

 
               # File optparse.rb, line 1227
def separator(string)
  top.append(string, nil, nil)
end
            
summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk) click to toggle source

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.

 
               # File optparse.rb, line 966
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
            
terminate(arg = nil) click to toggle source

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

 
               # File optparse.rb, line 803
def terminate(arg = nil)
  self.class.terminate(arg)
end
            
to_a() click to toggle source

Returns option summary list.

 
               # File optparse.rb, line 981
def to_a; summarize(banner.to_a.dup) end
            
to_s() click to toggle source
Alias for: help
top() click to toggle source

Subject of on / on_head, accept / reject

 
               # File optparse.rb, line 927
def top
  @stack[-1]
end
            
ver() click to toggle source

Returns version string from #program_name, version and release.

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

Version

 
               # File optparse.rb, line 894
def version
  @version || (defined?(::Version) && ::Version)
end
            
warn(mesg = $!) click to toggle source
 
               # File optparse.rb, line 916
def warn(mesg = $!)
  super("#{program_name}: #{mesg}")
end