OptionParser 類別

OptionParser

OptionParser 新手嗎?

請參閱 教學課程

簡介

OptionParser 是用於命令列選項分析的類別。它比 GetoptLong 進階許多,但使用起來也更簡單,而且是更偏向 Ruby 的解決方案。

功能

  1. 引數規格和處理它的程式碼寫在同一個地方。

  2. 它可以輸出選項摘要;您不需要另外維護這個字串。

  3. 可選引數和必要引數的指定非常優雅。

  4. 引數可以自動轉換為指定的類別。

  5. 引數可以限制在某個集合中。

以下範例會示範所有這些功能。請參閱 make_switch 以取得完整文件。

最小範例

require 'optparse'

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

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

p options
p ARGV

產生說明

OptionParser 可用來自動產生您編寫的指令說明

require 'optparse'

Options = Struct.new(:name)

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

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

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

      parser.on("-h", "--help", "Prints this help") do
        puts parser
        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

必填參數

對於需要參數的選項,選項規格字串可能包含全大寫的選項名稱。如果選項未帶入必填參數,將會引發例外狀況。

require 'optparse'

options = {}
OptionParser.new do |parser|
  parser.on("-r", "--require LIBRARY",
            "Require the LIBRARY before executing your script") do |lib|
    puts "You required #{lib}!"
  end
end.parse!

已使用

$ ruby optparse-test.rb -r
optparse-test.rb:9:in `<main>': missing argument: -r (OptionParser::MissingArgument)
$ ruby optparse-test.rb -r my-library
You required my-library!

類型轉換

OptionParser 支援將命令列參數轉換成物件的能力。

OptionParser 附帶幾種可立即使用的類型轉換。它們是

我們也可以新增自己的強制轉換,我們會在下方介紹。

使用內建轉換

舉例來說,使用了內建的 Time 轉換。其他內建轉換的行為方式相同。 OptionParser 會嘗試將參數解析為 Time。如果成功,該時間會傳遞給處理器區塊。否則,會引發例外。

require 'optparse'
require 'optparse/time'
OptionParser.new do |parser|
  parser.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
    p time
  end
end.parse!

已使用

$ ruby optparse-test.rb  -t nonsense
... invalid argument: -t nonsense (OptionParser::InvalidArgument)
$ ruby optparse-test.rb  -t 10-11-12
2010-11-12 00:00:00 -0500
$ ruby optparse-test.rb  -t 9:30
2014-08-13 09:30:00 -0400

建立自訂轉換

OptionParser 上的 accept 方法可用於建立轉換器。它會指定每當指定類別時要呼叫哪個轉換區塊。以下範例使用它在 on 處理器接收 User 物件之前擷取該物件。

require 'optparse'

User = Struct.new(:id, :name)

def find_user id
  not_found = ->{ raise "No User Found for id #{id}" }
  [ User.new(1, "Sam"),
    User.new(2, "Gandalf") ].find(not_found) do |u|
    u.id == id
  end
end

op = OptionParser.new
op.accept(User) do |user_id|
  find_user user_id.to_i
end

op.on("--user ID", User) do |user|
  puts user
end

op.parse!

已使用

$ ruby optparse-test.rb --user 1
#<struct User id=1, name="Sam">
$ ruby optparse-test.rb --user 2
#<struct User id=2, name="Gandalf">
$ ruby optparse-test.rb --user 3
optparse-test.rb:15:in `block in find_user': No User Found for id 3 (RuntimeError)

將選項儲存到 Hash

orderparse 等方法的 into 選項會將命令列選項儲存到 Hash 中。

require 'optparse'

options = {}
OptionParser.new do |parser|
  parser.on('-a')
  parser.on('-b NUM', Integer)
  parser.on('-v', '--verbose')
end.parse!(into: options)

p options

已使用

$ ruby optparse-test.rb -a
{:a=>true}
$ ruby optparse-test.rb -a -v
{:a=>true, :verbose=>true}
$ ruby optparse-test.rb -a -b 100
{:a=>true, :b=>100}

完整範例

以下範例是一個完整的 Ruby 程式。您可以執行它並查看指定各種選項的效果。這可能是學習 optparse 功能的最佳方式。

require 'optparse'
require 'optparse/time'
require 'ostruct'
require 'pp'

class OptparseExample
  Version = '1.0.0'

  CODES = %w[iso-2022-jp shift_jis euc-jp utf8 binary]
  CODE_ALIASES = { "jis" => "iso-2022-jp", "sjis" => "shift_jis" }

  class ScriptOptions
    attr_accessor :library, :inplace, :encoding, :transfer_type,
                  :verbose, :extension, :delay, :time, :record_separator,
                  :list

    def initialize
      self.library = []
      self.inplace = false
      self.encoding = "utf8"
      self.transfer_type = :auto
      self.verbose = false
    end

    def define_options(parser)
      parser.banner = "Usage: example.rb [options]"
      parser.separator ""
      parser.separator "Specific options:"

      # add additional options
      perform_inplace_option(parser)
      delay_execution_option(parser)
      execute_at_time_option(parser)
      specify_record_separator_option(parser)
      list_example_option(parser)
      specify_encoding_option(parser)
      optional_option_argument_with_keyword_completion_option(parser)
      boolean_verbose_option(parser)

      parser.separator ""
      parser.separator "Common options:"
      # No argument, shows at tail.  This will print an options summary.
      # Try it and see!
      parser.on_tail("-h", "--help", "Show this message") do
        puts parser
        exit
      end
      # Another typical switch to print the version.
      parser.on_tail("--version", "Show version") do
        puts Version
        exit
      end
    end

    def perform_inplace_option(parser)
      # Specifies an optional option argument
      parser.on("-i", "--inplace [EXTENSION]",
                "Edit ARGV files in place",
                "(make backup if EXTENSION supplied)") do |ext|
        self.inplace = true
        self.extension = ext || ''
        self.extension.sub!(/\A\.?(?=.)/, ".")  # Ensure extension begins with dot.
      end
    end

    def delay_execution_option(parser)
      # Cast 'delay' argument to a Float.
      parser.on("--delay N", Float, "Delay N seconds before executing") do |n|
        self.delay = n
      end
    end

    def execute_at_time_option(parser)
      # Cast 'time' argument to a Time object.
      parser.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
        self.time = time
      end
    end

    def specify_record_separator_option(parser)
      # Cast to octal integer.
      parser.on("-F", "--irs [OCTAL]", OptionParser::OctalInteger,
                "Specify record separator (default \\0)") do |rs|
        self.record_separator = rs
      end
    end

    def list_example_option(parser)
      # List of arguments.
      parser.on("--list x,y,z", Array, "Example 'list' of arguments") do |list|
        self.list = list
      end
    end

    def specify_encoding_option(parser)
      # 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(', ')
      parser.on("--code CODE", CODES, CODE_ALIASES, "Select encoding",
                "(#{code_list})") do |encoding|
        self.encoding = encoding
      end
    end

    def optional_option_argument_with_keyword_completion_option(parser)
      # Optional '--type' option argument with keyword completion.
      parser.on("--type [TYPE]", [:text, :binary, :auto],
                "Select transfer type (text, binary, auto)") do |t|
        self.transfer_type = t
      end
    end

    def boolean_verbose_option(parser)
      # Boolean switch.
      parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
        self.verbose = v
      end
    end
  end

  #
  # Return a structure describing the options.
  #
  def parse(args)
    # The options specified on the command line will be collected in
    # *options*.

    @options = ScriptOptions.new
    @args = OptionParser.new do |parser|
      @options.define_options(parser)
      parser.parse!(args)
    end
    @options
  end

  attr_reader :parser, :options
end  # class OptparseExample

example = OptparseExample.new
options = example.parse(ARGV)
pp options # example.options
pp ARGV

Shell Completion

對於現代 Shell(例如 bash、zsh 等),您可以對命令列選項使用 Shell 完成。

進一步的文件

上述範例,以及隨附的 教學課程,應該足以讓您學習如何使用這個類別。如果您有任何問題,請在 bugs.ruby-lang.org 提交問題單。

常數

DecimalInteger

十進位整數格式,將轉換為 Integer

DecimalNumeric

十進位整數/浮點數格式,將轉換為 Integer(整數格式)或 Float(浮點格式)。

OctalInteger

類似 Ruby/C 的八進位/十六進位/二進位整數格式,將轉換為 Integer

Version

屬性

banner[W]

摘要之前的標題橫幅。

default_argv[RW]

預設要分析的字串。

program_name[W]

要顯示在錯誤訊息和預設橫幅中的程式名稱,預設為 $0。

raise_unknown[RW]

是否要引發未知選項。

release[W]

發布代碼

require_exact[RW]

是否要求選項完全符合(不允許將縮寫的長選項提供為短選項)。

set_banner[W]

摘要之前的標題橫幅。

set_program_name[W]

要顯示在錯誤訊息和預設橫幅中的程式名稱,預設為 $0。

set_summary_indent[RW]

摘要的縮排。必須是 字串(或具有 + 字串 方法)。

set_summary_width[RW]

摘要中選項清單部分的寬度。必須是 數字

summary_indent[RW]

摘要的縮排。必須是 字串(或具有 + 字串 方法)。

summary_width[RW]

摘要中選項清單部分的寬度。必須是 數字

version[W]

公開類別方法

accept(*args, &blk) 按一下以切換來源

請參閱 accept

# File lib/optparse.rb, line 1190
def self.accept(*args, &blk) top.accept(*args, &blk) end
each_const(path, base = ::Object) 按一下以切換來源
# File lib/optparse/version.rb, line 50
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, symbolize_names: false) 按一下以切換來源

請參閱 getopts

# File lib/optparse.rb, line 1822
def self.getopts(*args, symbolize_names: false)
  new.getopts(*args, symbolize_names: symbolize_names)
end
inc(arg, default = nil) 按一下以切換來源

根據 arg 傳回 default 的增量值。

# File lib/optparse.rb, line 1124
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) { |self| ... } 按一下以切換來源

初始化執行個體,如果呼叫時帶有區塊,則讓渡給自己。

標語

標語訊息。

寬度

摘要寬度。

縮排

摘要縮排。

# File lib/optparse.rb, line 1143
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
  @require_exact = false
  @raise_unknown = true
  add_officious
  yield self if block_given?
end
reject(*args, &blk) 按一下以切換來源

請參閱 reject

# File lib/optparse.rb, line 1203
def self.reject(*args, &blk) top.reject(*args, &blk) end
search_const(klass, name) { |klass, cname, const| ... } 按一下以切換來源
# File lib/optparse/version.rb, line 60
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) 按一下以切換來源
# File lib/optparse/version.rb, line 5
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) 按一下以切換來源
# File lib/optparse.rb, line 1170
def self.terminate(arg = nil)
  throw :terminate, arg
end
top() 按一下以切換來源
# File lib/optparse.rb, line 1175
def self.top() DefaultList end
with(*args, &block) 按一下以切換來源

初始化新的執行個體,並在執行個體的內容中評估選用的區塊。引數 args 傳遞給 new,請參閱其中關於參數說明。

此方法已過時,其行為對應於舊版的 new 方法。

# File lib/optparse.rb, line 1115
def self.with(*args, &block)
  opts = new(*args)
  opts.instance_eval(&block)
  opts
end

公開執行個體方法

abort(mesg = $!) 按一下以切換來源
呼叫超類別方法 Kernel#abort
# File lib/optparse.rb, line 1291
def abort(mesg = $!)
  super("#{program_name}: #{mesg}")
end
accept(*args, &blk) 按一下以切換來源

指示接受指定的類別 t。引數字串傳遞給區塊,其中應將其轉換為所需的類別。

t

引數類別指定項,任何物件,包含 Class

pat

引數的模式,如果回應 match,則預設為 t

accept(t, pat, &block)
# File lib/optparse.rb, line 1186
def accept(*args, &blk) top.accept(*args, &blk) end
additional_message(typ, opt) 按一下以切換來源

傳回其他資訊。

# File lib/optparse.rb, line 1873
def additional_message(typ, opt)
  return unless typ and opt and defined?(DidYouMean::SpellChecker)
  all_candidates = []
  visit(:get_candidates, typ) do |candidates|
    all_candidates.concat(candidates)
  end
  all_candidates.select! {|cand| cand.is_a?(String) }
  checker = DidYouMean::SpellChecker.new(dictionary: all_candidates)
  DidYouMean.formatter.message_for(all_candidates & checker.correct(opt))
end
banner() 按一下以切換來源

摘要之前的標題橫幅。

base() 按一下以切換來源

on_tail 的主旨。

# File lib/optparse.rb, line 1305
def base
  @stack[1]
end
candidate(word) 按一下以切換來源
# File lib/optparse.rb, line 1884
def candidate(word)
  list = []
  case word
  when '-'
    long = short = true
  when /\A--/
    word, arg = word.split(/=/, 2)
    argpat = Completion.regexp(arg, false) if arg and !arg.empty?
    long = true
  when /\A-/
    short = true
  end
  pat = Completion.regexp(word, long)
  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
別名:define_head
def_option
別名:define
def_tail_option
別名:define_tail
define(*params, &block) 按一下以切換來源

從給定的參數 params 建立選項。請參閱新選項參數

如果給定區塊,則為建立的選項的處理常式。在命令列剖析期間遇到選項時,會呼叫區塊,並提供給選項的引數(如果有的話)。請參閱選項處理常式

# File lib/optparse.rb, line 1540
def define(*opts, &block)
  top.append(*(sw = make_switch(opts, block)))
  sw[0]
end
別名:def_option
define_by_keywords(options, method, **params) 按一下以切換來源

從給定的參數 params 建立選項。請參閱新選項參數

如果給定區塊,則為建立的選項的處理常式。在命令列剖析期間遇到選項時,會呼叫區塊,並提供給選項的引數(如果有的話)。請參閱選項處理常式

# File lib/optparse/kwargs.rb, line 10
def define_by_keywords(options, meth, **opts)
  meth.parameters.each do |type, name|
    case type
    when :key, :keyreq
      op, cl = *(type == :key ? %w"[ ]" : ["", ""])
      define("--#{name}=#{op}#{name.upcase}#{cl}", *opts[name]) do |o|
        options[name] = o
      end
    end
  end
  options
end
define_head(*params, &block) 按一下以切換來源

從給定的參數 params 建立選項。請參閱新選項參數

如果給定區塊,則為建立的選項的處理常式。在命令列剖析期間遇到選項時,會呼叫區塊,並提供給選項的引數(如果有的話)。請參閱選項處理常式

# File lib/optparse.rb, line 1561
def define_head(*opts, &block)
  top.prepend(*(sw = make_switch(opts, block)))
  sw[0]
end
別名:def_head_option
define_tail(*params, &block) 按一下以切換來源

從給定的參數 params 建立選項。請參閱新選項參數

如果給定區塊,則為建立的選項的處理常式。在命令列剖析期間遇到選項時,會呼叫區塊,並提供給選項的引數(如果有的話)。請參閱選項處理常式

# File lib/optparse.rb, line 1584
def define_tail(*opts, &block)
  base.append(*(sw = make_switch(opts, block)))
  sw[0]
end
別名:def_tail_option
environment(env = File.basename($0, '.*')) 按一下以切換來源

剖析環境變數 env 或其大寫,並像 shell 一樣分割。

env 預設為程式之基本名稱。

# File lib/optparse.rb, line 1957
def environment(env = File.basename($0, '.*'))
  env = ENV[env] || ENV[env.upcase] or return
  require 'shellwords'
  parse(*Shellwords.shellwords(env))
end
getopts(*args, symbolize_names: false) 按一下以切換來源

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

選項 symbolize_names(布林值)指定傳回的 Hash 鍵是否應為符號;預設為 false(使用字串)。

params = ARGV.getopts("ab:", "foo", "bar:", "zot:Z;zot option", symbolize_names: true)
# params[:a] = true   # -a
# params[:b] = "1"    # -b1
# params[:foo] = "1"  # --foo
# params[:bar] = "x"  # --bar x
# params[:zot] = "z"  # --zot Z
# File lib/optparse.rb, line 1787
def getopts(*args, symbolize_names: false)
  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(:[]=))
  symbolize_names ? result.transform_keys(&:to_sym) : result
end
help() 按一下以切換來源

傳回選項摘要字串。

# File lib/optparse.rb, line 1347
def help; summarize("#{banner}".sub(/\n?\z/, "\n")) end
別名:to_s
inc(*args) 按一下以切換來源
# File lib/optparse.rb, line 1132
def inc(*args)
  self.class.inc(*args)
end
load(filename = nil, into: nil) 按一下以切換來源

從檔案名稱載入選項,例如 filename。如果檔案不存在,則不執行任何動作。傳回是否載入成功。

filename 預設為程式在 ~/.options 目錄中的基本名稱,不含字尾,然後在 XDG 和 Haiku 標準位置中,基本名稱加上 `.options` 字尾。

選用的 into 關鍵字引數的作用,與方法 parse 中接受的引數完全相同。

# File lib/optparse.rb, line 1925
def load(filename = nil, into: nil)
  unless filename
    basename = File.basename($0, '.*')
    return true if load(File.expand_path(basename, '~/.options'), into: into) rescue nil
    basename << ".options"
    return [
      # XDG
      ENV['XDG_CONFIG_HOME'],
      '~/.config',
      *ENV['XDG_CONFIG_DIRS']&.split(File::PATH_SEPARATOR),

      # Haiku
      '~/config/settings',
    ].any? {|dir|
      next if !dir or dir.empty?
      load(File.expand_path(basename, dir), into: into) rescue nil
    }
  end
  begin
    parse(*File.readlines(filename, chomp: true), into: into)
    true
  rescue Errno::ENOENT, Errno::ENOTDIR
    false
  end
end
make_switch(params, block = nil) 按一下以切換來源

從給定的參數 params 建立選項。請參閱新選項參數

如果給定區塊,則為建立的選項的處理常式。在命令列剖析期間遇到選項時,會呼叫區塊,並提供給選項的引數(如果有的話)。請參閱選項處理常式

# File lib/optparse.rb, line 1402
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
  has_arg = false

  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}"
      (q = q.downcase).tr!('_', '-')
      long << "no-#{q}"
      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}"
      (o = q.downcase).tr!('_', '-')
      long << o
      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}"
      (o = q.downcase).tr!('_', '-')
      long << o
    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
      else
        has_arg = true
      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) if o && !o.empty?
    end
  end

  default_pattern, conv = search(:atype, default_style.pattern) unless default_pattern
  if !(short.empty? and long.empty?)
    if has_arg and default_style == Switch::NoArgument
      default_style = Switch::RequiredArgument
    end
    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() { |self| ... } 按一下以切換來源

新增一個 List

# File lib/optparse.rb, line 1312
def new
  @stack.push(List.new)
  if block_given?
    yield self
  else
    self
  end
end
on(*params, &block) 按一下以切換來源

從給定的參數 params 建立選項。請參閱新選項參數

如果給定區塊,則為建立的選項的處理常式。在命令列剖析期間遇到選項時,會呼叫區塊,並提供給選項的引數(如果有的話)。請參閱選項處理常式

# File lib/optparse.rb, line 1550
def on(*opts, &block)
  define(*opts, &block)
  self
end
on_head(*params, &block) 按一下以切換來源

從給定的參數 params 建立選項。請參閱新選項參數

如果給定區塊,則為建立的選項的處理常式。在命令列剖析期間遇到選項時,會呼叫區塊,並提供給選項的引數(如果有的話)。請參閱選項處理常式

將新選項新增至摘要的開頭。

# File lib/optparse.rb, line 1573
def on_head(*opts, &block)
  define_head(*opts, &block)
  self
end
on_tail(*params, &block) 按一下以切換來源

從給定的參數 params 建立選項。請參閱新選項參數

如果給定區塊,則為建立的選項的處理常式。在命令列剖析期間遇到選項時,會呼叫區塊,並提供給選項的引數(如果有的話)。請參閱選項處理常式

將新選項新增至摘要的結尾。

# File lib/optparse.rb, line 1597
def on_tail(*opts, &block)
  define_tail(*opts, &block)
  self
end
order(*argv, into: nil, &nonopt) 按一下以切換來源

依序分析命令列引數 argv。如果指定區塊,則會產生每個非選項引數。如果提供選用的 into 關鍵字引數,則會透過 []= 方法將已分析的選項值儲存在其中(因此它可以是 HashOpenStruct 或其他類似物件)。

傳回 argv 中未分析的其餘部分。

# File lib/optparse.rb, line 1619
def order(*argv, into: nil, &nonopt)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  order!(argv, into: into, &nonopt)
end
order!(argv = default_argv, into: nil, &nonopt) 按一下以切換來源

order 相同,但會破壞性地移除開關。非選項引數會保留在 argv 中。

# File lib/optparse.rb, line 1628
def order!(argv = default_argv, into: nil, &nonopt)
  setter = ->(name, val) {into[name.to_sym] = val} if into
  parse_in_order(argv, setter, &nonopt)
end
parse(*argv, into: nil) 按一下以切換來源

如果環境變數 POSIXLY_CORRECT 已設定,則會依序分析命令列引數 argv;否則,會以排列組合模式進行分析。如果提供選用的 into 關鍵字引數,則會透過 []= 方法將已分析的選項值儲存在其中(因此它可以是 HashOpenStruct 或其他類似物件)。

# File lib/optparse.rb, line 1751
def parse(*argv, into: nil)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  parse!(argv, into: into)
end
parse!(argv = default_argv, into: nil) 按一下以切換來源

parse 相同,但會破壞性地移除開關。非選項參數會保留在 argv 中。

# File lib/optparse.rb, line 1760
def parse!(argv = default_argv, into: nil)
  if ENV.include?('POSIXLY_CORRECT')
    order!(argv, into: into)
  else
    permute!(argv, into: into)
  end
end
permute(*argv, into: nil) 按一下以切換來源

以排列模式分析命令列參數 argv,並傳回非選項參數清單。當提供選用的 into 關鍵字參數時,已分析的選項值會透過 []= 方法儲存在其中 (因此它可以是 HashOpenStruct 或其他類似的物件)。

# File lib/optparse.rb, line 1728
def permute(*argv, into: nil)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  permute!(argv, into: into)
end
permute!(argv = default_argv, into: nil) 按一下以切換來源

permute 相同,但會破壞性地移除開關。非選項參數會保留在 argv 中。

# File lib/optparse.rb, line 1737
def permute!(argv = default_argv, into: nil)
  nonopts = []
  order!(argv, into: into, &nonopts.method(:<<))
  argv[0, 0] = nonopts
  argv
end
program_name() 按一下以切換來源

要顯示在錯誤訊息和預設橫幅中的程式名稱,預設為 $0。

# File lib/optparse.rb, line 1247
def program_name
  @program_name || File.basename($0, '.*')
end
reject(*args, &blk) 按一下以切換來源

指示拒絕指定的類別參數。

t

引數類別指定項,任何物件,包含 Class

reject(t)
# File lib/optparse.rb, line 1199
def reject(*args, &blk) top.reject(*args, &blk) end
release() 按一下以切換來源

發布代碼

# File lib/optparse.rb, line 1272
def release
  (defined?(@release) && @release) || (defined?(::Release) && ::Release) || (defined?(::RELEASE) && ::RELEASE)
end
remove() 按一下以切換來源

移除最後一個 List

# File lib/optparse.rb, line 1324
def remove
  @stack.pop
end
separator(string) 按一下以切換來源

在摘要中加入分隔符號。

# File lib/optparse.rb, line 1606
def separator(string)
  top.append(string, nil, nil)
end
summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk) 按一下以切換來源

將選項摘要放入 to,並傳回 to。如果給定區塊,則會產生每一行。

to

輸出目的地,必須有方法 <<。預設為 []。

寬度

左側寬度,預設為 @summary_width。

max

左側允許的最大長度,預設為 width - 1。

縮排

縮排,預設為 @summary_indent。

# File lib/optparse.rb, line 1337
def summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk)
  nl = "\n"
  blk ||= proc {|l| to << (l.index(nl, -1) ? l : l + nl)}
  visit(:summarize, {}, {}, width, max, indent, &blk)
  to
end
terminate(arg = nil) 按一下以切換來源

終止選項分析。選用參數 arg 是字串,會推回成為第一個非選項參數。

# File lib/optparse.rb, line 1167
def terminate(arg = nil)
  self.class.terminate(arg)
end
to_a() 按一下以切換來源

傳回選項摘要清單。

# File lib/optparse.rb, line 1376
def to_a; summarize("#{banner}".split(/^/)) end
to_s()
別名為:help
top() 按一下以切換來源

on / on_headaccept / reject 的主詞

# File lib/optparse.rb, line 1298
def top
  @stack[-1]
end
ver() 按一下以切換來源

傳回 program_name、版本和發行版的版本字串。

# File lib/optparse.rb, line 1279
def ver
  if v = version
    str = +"#{program_name} #{[v].join('.')}"
    str << " (#{v})" if v = release
    str
  end
end
version() 按一下以切換來源

Version

# File lib/optparse.rb, line 1265
def version
  (defined?(@version) && @version) || (defined?(::Version) && ::Version)
end
warn(mesg = $!) 按一下以切換來源
呼叫超類別方法 Kernel#warn
# File lib/optparse.rb, line 1287
def warn(mesg = $!)
  super("#{program_name}: #{mesg}")
end