класс OptionParser

# File lib/optparse.rb, line 1237
def self.accept(*args, &blk) top.accept(*args, &blk) end

# File lib/optparse.rb, line 1939
def self.getopts(*args, symbolize_names: false)
  new.getopts(*args, symbolize_names: symbolize_names)
end

# File lib/optparse.rb, line 1159
def self.inc(arg, default = nil)
  case arg
  when Integer
    arg.nonzero?
  when nil
    default.to_i + 1
  end
end

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

# File lib/optparse.rb, line 1250
def self.reject(*args, &blk) top.reject(*args, &blk) end

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

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

# File lib/optparse.rb, line 1222
def self.top() DefaultList end

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

# File lib/optparse.rb, line 1360
def abort(mesg = $!)
  super("#{program_name}: #{mesg}")
end

# File lib/optparse.rb, line 1233
def accept(*args, &blk) top.accept(*args, &blk) end

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

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

# File lib/optparse.rb, line 1374
def base
  @stack[1]
end

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

# File lib/optparse.rb, line 1631
def define(*opts, &block)
  top.append(*(sw = make_switch(opts, block)))
  sw[0]
end

# File lib/optparse/kwargs.rb, line 15
def define_by_keywords(options, method, **params)
  method.parameters.each do |type, name|
    case type
    when :key, :keyreq
      op, cl = *(type == :key ? %w"[ ]" : ["", ""])
      define("--#{name}=#{op}#{name.upcase}#{cl}", *params[name]) do |o|
        options[name] = o
      end
    end
  end
  options
end

# File lib/optparse.rb, line 1652
def define_head(*opts, &block)
  top.prepend(*(sw = make_switch(opts, block)))
  sw[0]
end

# File lib/optparse.rb, line 1675
def define_tail(*opts, &block)
  base.append(*(sw = make_switch(opts, block)))
  sw[0]
end

# File lib/optparse.rb, line 2082
def environment(env = File.basename($0, '.*'), **keywords)
  env = ENV[env] || ENV[env.upcase] or return
  require 'shellwords'
  parse(*Shellwords.shellwords(env), **keywords)
end

# File lib/optparse.rb, line 1901
def getopts(*args, symbolize_names: false, **keywords)
  argv = Array === args.first ? args.shift : default_argv
  single_options, *long_options = *args

  result = {}
  setter = (symbolize_names ?
              ->(name, val) {result[name.to_sym] = val}
            : ->(name, val) {result[name] = val})

  single_options.scan(/(.)(:)?/) do |opt, val|
    if val
      setter[opt, nil]
      define("-#{opt} VAL")
    else
      setter[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
      setter[opt, (val unless val.empty?)]
      define("--#{opt}=#{result[opt] || "VAL"}", *[desc].compact)
    else
      setter[opt, false]
      define("--#{opt}", *[desc].compact)
    end
  end

  parse_in_order(argv, setter, **keywords)
  result
end

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

# File lib/optparse.rb, line 1171
def inc(*args)
  self.class.inc(*args)
end

# File lib/optparse.rb, line 2042
def load(filename = nil, **keywords)
  unless filename
    basename = File.basename($0, '.*')
    return true if load(File.expand_path("~/.options/#{basename}"), **keywords) rescue nil
    basename << ".options"
    if !(xdg = ENV['XDG_CONFIG_HOME']) or xdg.empty?
      # https://specifications.freedesktop.org/basedir-spec/latest/#variables
      #
      # If $XDG_CONFIG_HOME is either not set or empty, a default
      # equal to $HOME/.config should be used.
      xdg = ['~/.config', true]
    end
    return [
      xdg,

      *ENV['XDG_CONFIG_DIRS']&.split(File::PATH_SEPARATOR),

      # Haiku
      ['~/config/settings', true],
    ].any? {|dir, expand|
      next if !dir or dir.empty?
      filename = File.join(dir, basename)
      filename = File.expand_path(filename) if expand
      load(filename, **keywords) rescue nil
    }
  end
  begin
    parse(*File.readlines(filename, chomp: true), **keywords)
    true
  rescue Errno::ENOENT, Errno::ENOTDIR
    false
  end
end

# File lib/optparse.rb, line 1473
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
  values = 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 !Completion.completable?(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, Set
      if Array === o
        o, v = o.partition {|v,| Completion.completable?(v)}
        values = notwice(v, values, 'values') unless v.empty?
        next if o.empty?
      end
      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 Range
      values = notwice(o, values, 'values')
    when Module
      raise ArgumentError, "unsupported argument type: #{o}", ParseError.filter_backtrace(caller(4))
    when *ArgumentStyle.keys
      style = notwice(ArgumentStyle[o], style, 'style')
    when /\A--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 /\A--\[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 /\A--([^\[\]=\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 /\A-(\[\^?\]?(?:[^\\\]]|\\.)*\])(.+)?/
      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 /\A-(.)(.+)?/
      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 /\A=/
      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 Range === values and klass
    unless (!values.begin or klass === values.begin) and
          (!values.end or klass === values.end)
      raise ArgumentError, "range does not match class"
    end
  end
  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, values)
  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, values)
  end
  return s, short, long,
    (not_style.new(not_pattern, not_conv, sdesc, ldesc, nil, desc, block) if not_style),
    nolong
end

# File lib/optparse.rb, line 1384
def new
  @stack.push(List.new)
  if block_given?
    yield self
  else
    self
  end
end

# File lib/optparse.rb, line 1641
def on(*opts, &block)
  define(*opts, &block)
  self
end

# File lib/optparse.rb, line 1664
def on_head(*opts, &block)
  define_head(*opts, &block)
  self
end

# File lib/optparse.rb, line 1688
def on_tail(*opts, &block)
  define_tail(*opts, &block)
  self
end

# File lib/optparse.rb, line 1717
def order(*argv, **keywords, &nonopt)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  order!(argv, **keywords, &nonopt)
end

# File lib/optparse.rb, line 1726
def order!(argv = default_argv, into: nil, **keywords, &nonopt)
  setter = ->(name, val) {into[name.to_sym] = val} if into
  parse_in_order(argv, setter, **keywords, &nonopt)
end

# File lib/optparse.rb, line 1865
def parse(*argv, **keywords)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  parse!(argv, **keywords)
end

# File lib/optparse.rb, line 1874
def parse!(argv = default_argv, **keywords)
  if ENV.include?('POSIXLY_CORRECT')
    order!(argv, **keywords)
  else
    permute!(argv, **keywords)
  end
end

# File lib/optparse.rb, line 1842
def permute(*argv, **keywords)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  permute!(argv, **keywords)
end

# File lib/optparse.rb, line 1851
def permute!(argv = default_argv, **keywords)
  nonopts = []
  order!(argv, **keywords) {|nonopt| nonopts << nonopt}
  argv[0, 0] = nonopts
  argv
end

# File lib/optparse.rb, line 1294
def program_name
  @program_name || strip_ext(File.basename($0))
end

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

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

# File lib/optparse.rb, line 1396
def remove
  @stack.pop
end

# File lib/optparse.rb, line 1697
def separator(string)
  top.append(string, nil, nil)
end

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

# File lib/optparse.rb, line 1206
def terminate(arg = nil)
  self.class.terminate(arg)
end

# File lib/optparse.rb, line 1448
def to_a; summarize("#{banner}".split(/^/)) end

# File lib/optparse.rb, line 1367
def top
  @stack[-1]
end

# File lib/optparse.rb, line 1334
def ver
  if v = version
    str = +"#{program_name} #{[v].join('.')}"
    str << " (#{v})" if v = release
    str
  end
end

# File lib/optparse.rb, line 1320
def version
  (defined?(@version) && @version) || (defined?(::Version) && ::Version)
end

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