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

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

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

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

end  # class OptparseExample

options = OptparseExample.parse(ARGV)
pp 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:

"\ntypeset -A opt_args\nlocal context state line\n\n_argume\n"      # :nodoc:
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


872
873
874
875
876
877
878
879
880
881
# File 'lib/optparse.rb', line 872

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.


955
956
957
958
959
960
961
# File 'lib/optparse.rb', line 955

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

#default_argvObject

Strings to be parsed in default.


950
951
952
# File 'lib/optparse.rb', line 950

def default_argv
  @default_argv
end

#program_nameObject

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


967
968
969
# File 'lib/optparse.rb', line 967

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

#releaseObject

Release code


992
993
994
# File 'lib/optparse.rb', line 992

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

#summary_indentObject

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


947
948
949
# File 'lib/optparse.rb', line 947

def summary_indent
  @summary_indent
end

#summary_widthObject

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


944
945
946
# File 'lib/optparse.rb', line 944

def summary_width
  @summary_width
end

#versionObject

Version


985
986
987
# File 'lib/optparse.rb', line 985

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

Class Method Details

.accept(*args, &blk) ⇒ Object

See #accept.


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

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

.getopts(*args) ⇒ Object

See #getopts.


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

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

.inc(arg, default = nil) ⇒ Object

Returns an incremented value of default according to arg.


853
854
855
856
857
858
859
860
# File 'lib/optparse.rb', line 853

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.


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

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

.terminate(arg = nil) ⇒ Object


897
898
899
# File 'lib/optparse.rb', line 897

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

.topObject


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

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.


844
845
846
847
848
# File 'lib/optparse.rb', line 844

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

Instance Method Details

#abort(mesg = $!) ⇒ Object


1011
1012
1013
# File 'lib/optparse.rb', line 1011

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)

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

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

#add_officiousObject

:nodoc:


883
884
885
886
887
888
# File 'lib/optparse.rb', line 883

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

#baseObject

Subject of #on_tail.


1025
1026
1027
# File 'lib/optparse.rb', line 1025

def base
  @stack[1]
end

#candidate(word) ⇒ Object


1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
# File 'lib/optparse.rb', line 1548

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


761
762
763
764
765
766
767
768
# File 'lib/optparse.rb', line 761

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


1274
1275
1276
1277
# File 'lib/optparse.rb', line 1274

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


1289
1290
1291
1292
# File 'lib/optparse.rb', line 1289

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


1303
1304
1305
1306
# File 'lib/optparse.rb', line 1303

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.


1605
1606
1607
1608
1609
# File 'lib/optparse.rb', line 1605

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:")
# params[:a] = true   # -a
# params[:b] = "1"    # -b1
# params[:foo] = "1"  # --foo
# params[:bar] = "x"  # --bar x

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
# File 'lib/optparse.rb', line 1467

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

#helpObject Also known as: to_s

Returns option summary string.


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

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

#inc(*args) ⇒ Object


861
862
863
# File 'lib/optparse.rb', line 861

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.


1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
# File 'lib/optparse.rb', line 1585

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) ⇒ 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"
Handler:

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


1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
# File 'lib/optparse.rb', line 1150

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

  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

#newObject

Pushes a new List.


1032
1033
1034
1035
1036
1037
1038
1039
# File 'lib/optparse.rb', line 1032

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.


1283
1284
1285
1286
# File 'lib/optparse.rb', line 1283

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.


1297
1298
1299
1300
# File 'lib/optparse.rb', line 1297

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.


1311
1312
1313
1314
# File 'lib/optparse.rb', line 1311

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

#order(*argv, &block) ⇒ Object

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.


1330
1331
1332
1333
# File 'lib/optparse.rb', line 1330

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

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


1339
1340
1341
# File 'lib/optparse.rb', line 1339

def order!(argv = default_argv, &nonopt)
  parse_in_order(argv, &nonopt)
end

#parse(*argv) ⇒ Object

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


1441
1442
1443
1444
# File 'lib/optparse.rb', line 1441

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

#parse!(argv = default_argv) ⇒ Object

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


1450
1451
1452
1453
1454
1455
1456
# File 'lib/optparse.rb', line 1450

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

#permute(*argv) ⇒ Object

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


1421
1422
1423
1424
# File 'lib/optparse.rb', line 1421

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

#permute!(argv = default_argv) ⇒ Object

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


1430
1431
1432
1433
1434
1435
# File 'lib/optparse.rb', line 1430

def permute!(argv = default_argv)
  nonopts = []
  order!(argv, &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)

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

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

#removeObject

Removes the last List.


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

def remove
  @stack.pop
end

#separator(string) ⇒ Object

Add separator in summary.


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

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.


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

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

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


894
895
896
# File 'lib/optparse.rb', line 894

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

#to_aObject

Returns option summary list.


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

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

#topObject

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


1018
1019
1020
# File 'lib/optparse.rb', line 1018

def top
  @stack[-1]
end

#verObject

Returns version string from program_name, version and release.


999
1000
1001
1002
1003
1004
1005
# File 'lib/optparse.rb', line 999

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

#warn(mesg = $!) ⇒ Object


1007
1008
1009
# File 'lib/optparse.rb', line 1007

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