OptionParser

Developer Documentation (not for RDoc output)

Class tree

OptionParser

front end
OptionParser::Switch

each switches
OptionParser::List

options list
OptionParser::ParseError

errors on parsing

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

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

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

Minimal example

require 'optparse'

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

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

p options
p ARGV

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

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, email me (gsinclair@soyabean.com.au) and I will update this document.

Namespace

Methods

A

abort,
accept,
accept

B

banner,
base

C

candidate,
complete

D

def_head_option,
def_option,
def_tail_option,
define,
define_head,
define_tail

E

each_const,
environment

G

getopts,
getopts

H

help

I

inc,
inc

L

load

M

make_switch

N

new,
new,
notwice

O

on,
on_head,
on_tail,
order,
order!

P

parse,
parse!,
permute,
permute!,
program_name

R

reject,
reject,
release,
remove

S

search,
search_const,
separator,
show_version,
summarize

T

terminate,
terminate,
to_a,
to_s,
top,
top

V

ver,
version,
visit

W

warn,
with

Constants

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

DecimalInteger	=	/\A[-+]?#{decimal}\z/io
	Decimal integer format, to be converted to Integer.
OctalInteger	=	/\A[-+]?(?:[0-7]+(?:_[0-7]+)*\|0(?:#{binary}\|#{hex}))\z/io
	Ruby/C like octal/hexadecimal/binary integer format, to be converted to Integer.
DecimalNumeric	=	floatpat # decimal integer is allowed as float also.
	Decimal integer/float number format, to be converted to Integer for integer format, Float for float format.

Attributes

[W]	banner	Heading banner preceding summary.
[RW]	default_argv	Strings to be parsed in default.
[W]	program_name	Program name to be emitted in error message and default banner, defaults to $0.
[W]	release	Release code
[W]	set_banner	Heading banner preceding summary.
[W]	set_program_name	Program name to be emitted in error message and default banner, defaults to $0.
[RW]	set_summary_indent	Indentation for summary. Must be String (or have + String method).
[RW]	set_summary_width	Width for option list portion of summary. Must be Numeric.
[RW]	summary_indent	Indentation for summary. Must be String (or have + String method).
[RW]	summary_width	Width for option list portion of summary. Must be Numeric.
[W]	version	Version

Class Public methods

accept(*args, &blk) Link

Class OptionParser < Object

Developer Documentation (not for RDoc output)

Class tree

Object relationship diagram

OptionParser

Introduction

Features

Minimal example

Complete example

Shell Completion

Further documentation