Class: OptionParser (Ruby 2.2.3)
Description: Class : OptionParser - Ruby 2.2.3

- Home
- Core 2.2.3
- Std-lib 2.2.3
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- optparse.rb
- optparse/ac.rb
- optparse/date.rb
- optparse/time.rb

### Parent

Object

### Methods

- ::accept
- ::each_const
- ::getopts
- ::inc
- ::new
- ::reject
- ::search_const
- ::show_version
- ::terminate
- ::top
- ::with
- #abort
- #accept
- #banner
- #base
- #candidate
- #def_head_option
- #def_option
- #def_tail_option
- #define
- #define_head
- #define_tail
- #environment
- #getopts
- #help
- #inc
- #load
- #make_switch
- #new
- #on
- #on_head
- #on_tail
- #order
- #order!
- #parse
- #parse!
- #permute
- #permute!
- #program_name
- #reject
- #release
- #remove
- #separator
- #summarize
- #terminate
- #to_a
- #to_s
- #top
- #ver
- #version
- #warn

### Class/Module Index

Quicksearch

- Object
- OptParse
- OptionParser
- OptionParser::AC
- OptionParser::Acceptables
- OptionParser::AmbiguousArgument
- OptionParser::AmbiguousOption
- OptionParser::Arguable
- OptionParser::CompletingHash
- OptionParser::Completion
- OptionParser::InvalidArgument
- OptionParser::InvalidOption
- OptionParser::List
- OptionParser::MissingArgument
- OptionParser::NeedlessArgument
- OptionParser::OptionMap
- OptionParser::ParseError
- OptionParser::Regexp
- OptionParser::Switch
- OptionParser::Switch::NoArgument
- OptionParser::Switch::OptionalArgument
- OptionParser::Switch::PlacedArgument
- OptionParser::Switch::RequiredArgument

No matching classes.

# OptionParser

## 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

### Generating Help¶ ↑

OptionParser can be used to automatically generate help for the commands you write:

    require 'optparse'

    Options = Struct.new(:name)

    class Parser
      def self.parse(options)
        args = Options.new("world")

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

          opts.on("-nNAME", "--name=NAME", "Name to say hello to") do |n|
            args.name = n
          end

          opts.on("-h", "--help", "Prints this help") do
            puts opts
            exit
          end
        end

        opt_parser.parse!(options)
        return args
      end
    end
    options = Parser.parse %w[--help]

    #=>
       # Usage: example.rb [options]
       #     -n, --name=NAME                  Name to say hello to
       #     -h, --help                       Prints this help#

### 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.

### 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

banner[W]

Heading banner preceding summary.

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 954
    def self.accept(*args, &blk) top.accept(*args, &blk) end

each_const(path, base = ::Object) click to toggle source

                   # 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}/i) do |c|
          klass.const_defined?(c) or next
          klass.const_get(c)
        end
      end
    end

getopts(*args) click to toggle source

See getopts.

                   # File optparse.rb, line 1540
    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 890
    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 909
    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 967
    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(*pkgs) click to toggle source

                   # 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] == ?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

terminate(arg = nil) click to toggle source

                   # File optparse.rb, line 934
    def self.terminate(arg = nil)
      throw :terminate, arg
    end

top() click to toggle source

                   # File optparse.rb, line 939
    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 881
    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 1048
    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 950
    def accept(*args, &blk) top.accept(*args, &blk) end

banner() click to toggle source

Heading banner preceding summary.

                   # File optparse.rb, line 992
    def banner
      unless @banner
        @banner = "Usage: #{program_name} [options]"
        visit(:add_banner, @banner)
      end
      @banner
    end

base() click to toggle source

Subject of on_tail.

                   # File optparse.rb, line 1062
    def base
      @stack[1]
    end

candidate(word) click to toggle source

                   # File optparse.rb, line 1587
    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

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 1311
    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 1326
    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 1340
    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 1644
    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:", "zot:Z;zot option)
    # params[:a] = true   # -a
    # params[:b] = "1"    # -b1
    # params[:foo] = "1"  # --foo
    # params[:bar] = "x"  # --bar x
    # params[:zot] = "z"  # --zot Z

                   # File optparse.rb, line 1505
    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|
        arg, desc = arg.split(';', 2)
        opt, val = arg.split(':', 2)
        if val
          result[opt] = val.empty? ? nil : val
          define("--#{opt}=#{result[opt] || "VAL"}", *[desc].compact)
        else
          result[opt] = false
          define("--#{opt}", *[desc].compact)
        end
      end

      parse_in_order(argv, result.method(:[]=))
      result
    end

help() click to toggle source

Returns option summary string.

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

Also aliased as: to_s
inc(*args) click to toggle source

                   # File optparse.rb, line 898
    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 1624
    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 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.

                   # File optparse.rb, line 1187
    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

new() click to toggle source

Pushes a new List.

                   # File optparse.rb, line 1069
    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 1320
    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 1334
    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 1348
    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 1367
    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. Non-option arguments remain in `argv`.

                   # File optparse.rb, line 1376
    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 1478
    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. Non-option arguments remain in `argv`.

                   # File optparse.rb, line 1487
    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 1458
    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. Non-option arguments remain in `argv`.

                   # File optparse.rb, line 1467
    def permute!(argv = default_argv)
      nonopts = []
      order!(argv, &nonopts.method(:<<))
      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 1004
    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 specifier, any object including Class.

    reject(t)

                   # File optparse.rb, line 963
    def reject(*args, &blk) top.reject(*args, &blk) end

release() click to toggle source

Release code

                   # File optparse.rb, line 1029
    def release
      @release || (defined?(::Release) && ::Release) || (defined?(::RELEASE) && ::RELEASE)
    end

remove() click to toggle source

Removes the last List.

                   # File optparse.rb, line 1081
    def remove
      @stack.pop
    end

separator(string) click to toggle source

Add separator in summary.

                   # File optparse.rb, line 1357
    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 1094
    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 931
    def terminate(arg = nil)
      self.class.terminate(arg)
    end

to_a() click to toggle source

Returns option summary list.

                   # File optparse.rb, line 1109
    def to_a; summarize("#{banner}".split(/^/)) 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 1055
    def top
      @stack[-1]
    end

ver() click to toggle source

Returns version string from #program_name, version and release.

                   # File optparse.rb, line 1036
    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 1022
    def version
      @version || (defined?(::Version) && ::Version)
    end

warn(mesg = $!) click to toggle source

                   # File optparse.rb, line 1044
    def warn(mesg = $!)
      super("#{program_name}: #{mesg}")
    end