Class: OptionParser

Inherits:
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.

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.

Defined Under Namespace

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

Constant Summary

RCSID =

:stopdoc:

%w$Id: optparse.rb 27089 2010-03-29 09:10:12Z nobu $[1..-1].each {|s| s.freeze}.freeze
Version = 
(RCSID[1].split('.').collect {|s| s.to_i}.extend(Comparable).freeze if RCSID[1])
LastModified = 
(Time.gm(*RCSID[2, 2].join('-').scan(/\d+/).collect {|s| s.to_i}) if RCSID[2])
Release = 
RCSID[2]
NoArgument = 
[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 dealed as argument.

{}
DefaultList =

Switches common used such as '--', and also provides default argument classes

List.new
Officious =

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

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

Decimal integer format, to be converted to Integer.

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

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

/\A[-+]?(?:[0-7]+(?:_[0-7]+)*|0(?:#{binary}|#{hex}))/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

- (OptionParser) initialize(banner = nil, width = 32, indent = ' ' * 4) {|_self| ... }

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



791
792
793
794
795
796
797
798
799
800
 
# File 'lib/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

Instance Attribute Details

Heading banner preceding summary.



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

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

- (Object) default_argv

Strings to be parsed in default.



869
870
871
 
# File 'lib/optparse.rb', line 869

def default_argv
  @default_argv
end

- (Object) program_name

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



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

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

- (Object) release

Release code



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

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

- (Object) summary_indent

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



866
867
868
 
# File 'lib/optparse.rb', line 866

def summary_indent
  @summary_indent
end

- (Object) summary_width

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



863
864
865
 
# File 'lib/optparse.rb', line 863

def summary_width
  @summary_width
end

- (Object) version

Version



904
905
906
 
# File 'lib/optparse.rb', line 904

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

Class Method Details

+ (Object) accept(*args, &blk)

See #accept.



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

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

+ (Object) each_const(path, base = ::Object) 



49
50
51
52
53
54
55
56
57
 
# File 'lib/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}/i) do |c|
      klass.const_defined?(c) or next
      c = klass.const_get(c)
    end
  end
end

+ (Object) getopts(*args)

See #getopts.



1417
1418
1419
 
# File 'lib/optparse.rb', line 1417

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

+ (Object) inc(arg, default = nil)

Returns an incremented value of default according to arg.



772
773
774
775
776
777
778
779
 
# File 'lib/optparse.rb', line 772

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

+ (Object) reject(*args, &blk)

See #reject.



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

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

+ (Object) search_const(klass, name) 



59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/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

+ (Object) show_version(*pkgs) 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/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] == ?e 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

+ (Object) terminate(arg = nil) 



816
817
818
 
# File 'lib/optparse.rb', line 816

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

+ (Object) top 



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

def self.top() DefaultList end

+ (Object) with(*args, &block)

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.



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

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

Instance Method Details

- (Object) abort(mesg = $!) 



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

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

- (Object) accept(*args, &blk)

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)


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

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

- (Object) add_officious

:nodoc:



802
803
804
805
806
807
 
# File 'lib/optparse.rb', line 802

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

- (Object) base

Subject of #on_tail.



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

def base
  @stack[1]
end

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



1193
1194
1195
1196
 
# File 'lib/optparse.rb', line 1193

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

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



1208
1209
1210
1211
 
# File 'lib/optparse.rb', line 1208

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

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



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

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

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

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

env defaults to the basename of the program.



1491
1492
1493
1494
1495
 
# File 'lib/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

- (Object) getopts(*args)

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


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
 
# File 'lib/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

- (Object) help Also known as: to_s

Returns option summary string.



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

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

- (Object) inc(*args) 



780
781
782
 
# File 'lib/optparse.rb', line 780

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

- (Object) load(filename = nil)

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.



1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
 
# File 'lib/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

- (Object) make_switch(opts, block = nil)

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.



1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
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
 
# File 'lib/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

- (Object) new

Pushes a new List.



951
952
953
954
955
956
957
958
 
# File 'lib/optparse.rb', line 951

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

- (Object) on(*opts, &block)

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



1202
1203
1204
1205
 
# File 'lib/optparse.rb', line 1202

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

- (Object) on_head(*opts, &block)

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



1216
1217
1218
1219
 
# File 'lib/optparse.rb', line 1216

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

- (Object) on_tail(*opts, &block)

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



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

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

- (Object) order(*argv, &block)

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.



1249
1250
1251
1252
 
# File 'lib/optparse.rb', line 1249

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

- (Object) order!(argv = default_argv, &nonopt)

Same as #order, but removes switches destructively.



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

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

- (Object) parse(*argv)

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



1358
1359
1360
1361
 
# File 'lib/optparse.rb', line 1358

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

- (Object) parse!(argv = default_argv)

Same as #parse, but removes switches destructively.



1366
1367
1368
1369
1370
1371
1372
 
# File 'lib/optparse.rb', line 1366

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

- (Object) permute(*argv)

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



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

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

- (Object) permute!(argv = default_argv)

Same as #permute, but removes switches destructively.



1347
1348
1349
1350
1351
1352
 
# File 'lib/optparse.rb', line 1347

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

- (Object) reject(*args, &blk)

Directs to reject specified class argument.

t

Argument class specifier, any object including Class.

reject(t)


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

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

- (Object) remove

Removes the last List.



963
964
965
 
# File 'lib/optparse.rb', line 963

def remove
  @stack.pop
end

- (Object) separator(string)

Add separator in summary.



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

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

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

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.



976
977
978
979
980
 
# File 'lib/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

- (Object) terminate(arg = nil)

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



813
814
815
 
# File 'lib/optparse.rb', line 813

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

- (Object) to_a

Returns option summary list.



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

def to_a; summarize(banner.to_a.dup) end

- (Object) top

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



937
938
939
 
# File 'lib/optparse.rb', line 937

def top
  @stack[-1]
end

- (Object) ver

Returns version string from program_name, version and release.



918
919
920
921
922
923
924
 
# File 'lib/optparse.rb', line 918

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

- (Object) warn(mesg = $!) 



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

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