front end |
each switches |
options list |
errors on parsing |
+--------------+ | OptionParser |<>-----+ +--------------+ | +--------+ | ,-| Switch | on_head -------->+---------------+ / +--------+ accept/reject -->| List |<|>- | |<|>- +----------+ on ------------->+---------------+ `-| argument | : : | class | +---------------+ |==========| on_tail -------->| | |pattern | +---------------+ |----------| OptionParser.accept ->| DefaultList | |converter | reject |(shared between| +----------+ | all instances)| +---------------+
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.
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.
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
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
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.
Decimal integer format, to be converted to Integer.
Decimal integer/float number format, to be converted to Integer for integer format, Float for float format.
Ruby/C like octal/hexadecimal/binary integer format, to be converted to Integer.
See accept.
# File optparse.rb, line 836
def self.accept(*args, &blk) top.accept(*args, &blk) end
# File optparse/version.rb, line 49
def each_const(path, base = ::Object)
path.split(/::|\//).inject(base) do |klass, name|
raise NameError, path unless Module === klass
klass.constants.grep(/#{name}/) do |c|
klass.const_defined?(c) or next
c = klass.const_get(c)
end
end
end
See getopts.
# File optparse.rb, line 1417
def self.getopts(*args)
new.getopts(*args)
end
Returns an incremented value of default according to arg.
# File optparse.rb, line 772
def self.inc(arg, default = nil)
case arg
when Integer
arg.nonzero?
when nil
default.to_i + 1
end
end
Initializes the instance and yields itself if called with a block.
banner |
Banner message. |
width |
Summary width. |
indent |
Summary indent. |
# File optparse.rb, line 791
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
See reject.
# File optparse.rb, line 849
def self.reject(*args, &blk) top.reject(*args, &blk) end
# 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
# File optparse/version.rb, line 4
def show_version(*pkgs)
progname = ARGV.options.program_name
result = false
show = proc do |klass, cname, version|
str = "#{progname}"
unless klass == ::Object and cname == :VERSION
version = version.join(".") if Array === version
str << ": #{klass}" unless klass == Object
str << " version #{version}"
end
[:Release, :RELEASE].find do |rel|
if klass.const_defined?(rel)
str << " (#{klass.const_get(rel)})"
end
end
puts str
result = true
end
if pkgs.size == 1 and pkgs[0] == "all"
self.search_const(::Object, /\AV(?:ERSION|ersion)\z/) do |klass, cname, version|
unless cname[1] == ee 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
# File optparse.rb, line 816
def self.terminate(arg = nil)
throw :terminate, arg
end
Initializes a new instance and evaluates the optional block in context of the instance. Arguments args are passed to new, see there for description of parameters.
This method is deprecated, its behavior corresponds to the older new method.
# File optparse.rb, line 763
def self.with(*args, &block)
opts = new(*args)
opts.instance_eval(&block)
opts
end
# File optparse.rb, line 930
def abort(mesg = $!)
super("#{program_name}: #{mesg}")
end
Directs to accept specified class t. The argument string is passed to the block in which it should be converted to the desired class.
t |
Argument class specifier, any object including Class. |
pat |
Pattern for argument, defaults to t if it responds to match. |
accept(t, pat, &block)
# File optparse.rb, line 832
def accept(*args, &blk) top.accept(*args, &blk) end
Subject of on_tail.
# File optparse.rb, line 944
def base
@stack[1]
end
# File optparse.rb, line 1193
def define(*opts, &block)
top.append(*(sw = make_switch(opts, block)))
sw[0]
end
# File optparse.rb, line 1208
def define_head(*opts, &block)
top.prepend(*(sw = make_switch(opts, block)))
sw[0]
end
# File optparse.rb, line 1222
def define_tail(*opts, &block)
base.append(*(sw = make_switch(opts, block)))
sw[0]
end
Parses environment variable env or its uppercase with splitting like a shell.
env defaults to the basename of the program.
# File optparse.rb, line 1491
def environment(env = File.basename($0, '.*'))
env = ENV[env] || ENV[env.upcase] or return
require 'shellwords'
parse(*Shellwords.shellwords(env))
end
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 1383
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
Returns option summary string.
# File optparse.rb, line 985
def help; summarize(banner.to_s.sub(/\n?\z/, "\n")) end
# File optparse.rb, line 780
def inc(*args)
self.class.inc(*args)
end
Loads options from file names as filename. Does nothing when the file is not present. Returns whether successfully loaded.
filename defaults to basename of the program without suffix in a directory ~/.options.
# File optparse.rb, line 1471
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
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:
One of the following:
:NONE, :REQUIRED, :OPTIONAL
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
Hash or Array.
[:text, :binary, :auto] %w[iso-2022-jp shift_jis euc-jp utf8 binary] { "jis" => "iso-2022-jp", "sjis" => "shift_jis" }
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"
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]"
Instead of specifying mandatory or optional arguments directly in the switch parameter, this separate parameter can be used.
"=MANDATORY" "=[OPTIONAL]"
Description string for the option.
"Run verbosely"
Handler for the parsed argument value. Either give a block or pass a Proc or Method as an argument.
# File optparse.rb, line 1069
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
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 || Symbol === o)) and o.respond_to?(:match)
pattern = notwice(o, pattern, 'pattern')
if pattern.respond_to?(:convert)
conv = pattern.method(:convert).to_proc
else
conv = SPLAT_PROC
end
next
end
# anything others
case o
when Proc, Method
block = notwice(o, block, 'block')
when Array, Hash
case pattern
when CompletingHash
when nil
pattern = CompletingHash.new
conv = pattern.method(:convert).to_proc if pattern.respond_to?(:convert)
else
raise ArgumentError, "argument pattern given twice"
end
o.each {|pat, *v| pattern[pat] = v.fetch(0) {pat}}
when Module
raise ArgumentError, "unsupported argument type: #{o}", ParseError.filter_backtrace(caller(4))
when *ArgumentStyle.keys
style = notwice(ArgumentStyle[o], style, 'style')
when /^--no-([^\[\]=\s]*)(.+)?/
q, a = $1, $2
o = notwice(a ? Object : TrueClass, klass, 'type')
not_pattern, not_conv = search(:atype, o) unless not_style
not_style = (not_style || default_style).guess(arg = a) if a
default_style = Switch::NoArgument
default_pattern, conv = search(:atype, FalseClass) unless default_pattern
ldesc << "--no-#{q}"
long << 'no-' + (q = q.downcase)
nolong << q
when /^--\[no-\]([^\[\]=\s]*)(.+)?/
q, a = $1, $2
o = notwice(a ? Object : TrueClass, klass, 'type')
if a
default_style = default_style.guess(arg = a)
default_pattern, conv = search(:atype, o) unless default_pattern
end
ldesc << "--[no-]#{q}"
long << (o = q.downcase)
not_pattern, not_conv = search(:atype, FalseClass) unless not_style
not_style = Switch::NoArgument
nolong << 'no-' + o
when /^--([^\[\]=\s]*)(.+)?/
q, a = $1, $2
if a
o = notwice(NilClass, klass, 'type')
default_style = default_style.guess(arg = a)
default_pattern, conv = search(:atype, o) unless default_pattern
end
ldesc << "--#{q}"
long << (o = q.downcase)
when /^-(\[\^?\]?(?:[^\\\]]|\\.)*\])(.+)?/
q, a = $1, $2
o = notwice(Object, klass, 'type')
if a
default_style = default_style.guess(arg = a)
default_pattern, conv = search(:atype, o) unless default_pattern
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
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
Pushes a new List.
# File optparse.rb, line 951
def new
@stack.push(List.new)
if block_given?
yield self
else
self
end
end
Add option switch and handler. See make_switch for an explanation of parameters.
# File optparse.rb, line 1202
def on(*opts, &block)
define(*opts, &block)
self
end
Add option switch like with on, but at head of summary.
# File optparse.rb, line 1216
def on_head(*opts, &block)
define_head(*opts, &block)
self
end
Add option switch like with on, but at tail of summary.
# File optparse.rb, line 1230
def on_tail(*opts, &block)
define_tail(*opts, &block)
self
end
Parses command line arguments argv in order. When a block is given, each non-option argument is yielded.
Returns the rest of argv left unparsed.
# File optparse.rb, line 1249
def order(*argv, &block)
argv = argv[0].dup if argv.size == 1 and Array === argv[0]
order!(argv, &block)
end
Same as order, but removes switches destructively.
# File optparse.rb, line 1257
def order!(argv = default_argv, &nonopt)
parse_in_order(argv, &nonopt)
end
Parses command line arguments argv in order when environment variable POSIXLY_CORRECT is set, and in permutation mode otherwise.
# File optparse.rb, line 1358
def parse(*argv)
argv = argv[0].dup if argv.size == 1 and Array === argv[0]
parse!(argv)
end
Same as parse, but removes switches destructively.
# File optparse.rb, line 1366
def parse!(argv = default_argv)
if ENV.include?('POSIXLY_CORRECT')
order!(argv)
else
permute!(argv)
end
end
Parses command line arguments argv in permutation mode and returns list of non-option arguments.
# File optparse.rb, line 1339
def permute(*argv)
argv = argv[0].dup if argv.size == 1 and Array === argv[0]
permute!(argv)
end
Same as permute, but removes switches destructively.
# File optparse.rb, line 1347
def permute!(argv = default_argv)
nonopts = []
order!(argv, &nonopts.method(:<<))
argv[0, 0] = nonopts
argv
end
Program name to be emitted in error message and default banner, defaults to $0.
# File optparse.rb, line 886
def program_name
@program_name || File.basename($0, '.*')
end
Directs to reject specified class argument.
t |
Argument class specifier, any object including Class. |
reject(t)
# File optparse.rb, line 845
def reject(*args, &blk) top.reject(*args, &blk) end
Release code
# File optparse.rb, line 911
def release
@release || (defined?(::Release) && ::Release) || (defined?(::RELEASE) && ::RELEASE)
end
Removes the last List.
# File optparse.rb, line 963
def remove
@stack.pop
end
Add separator in summary.
# File optparse.rb, line 1239
def separator(string)
top.append(string, nil, nil)
end
Puts option summary into to and returns to. Yields each line if a block is given.
to |
Output destination, which must have method <<. Defaults to []. |
width |
Width of left side, defaults to @summary_width. |
max |
Maximum length allowed for left side, defaults to width - 1. |
indent |
Indentation, defaults to @summary_indent. |
# File optparse.rb, line 976
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
Terminates option parsing. Optional parameter arg is a string pushed back to be the first non-option argument.
# File optparse.rb, line 813
def terminate(arg = nil)
self.class.terminate(arg)
end
Returns option summary list.
# File optparse.rb, line 991
def to_a; summarize(banner.to_a.dup) end
Returns version string from program_name, version and release.
# File optparse.rb, line 918
def ver
if v = version
str = "#{program_name} #{[v].join('.')}"
str << " (#{v})" if v = release
str
end
end