class OptionParser

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

# 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

# File lib/optparse.rb, line 1501
def self.getopts(*args)
 new.getopts(*args)
end

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

# File lib/optparse.rb, line 872
def initialize(banner = nil, width = 32, indent = ' ' * 4)
 @stack = [DefaultList, List.new, List.new]
 @program_name = nil
 @banner = banner
 @summary_width = width
 @summary_indent = indent
 @default_argv = ARGV
 add_officious
 yield self if block_given?
end

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

# 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

# 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

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

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

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

Calls superclass method Kernel#abort

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

accept(t, pat, &block)

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

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

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

# File lib/optparse.rb, line 1548
def candidate(word)
 list = []
 case word
 when /\A--/
 word, arg = word.split(/=/, 2)
 argpat = Completion.regexp(arg, false) if arg and !arg.empty?
 long = true
 when /\A-(!-)/
 short = true
 when /\A-/
 long = short = true
 end
 pat = Completion.regexp(word, true)
 visit(:each_option) do |opt|
 next unless Switch === opt
 opts = (long ? opt.long : []) + (short ? opt.short : [])
 opts = Completion.candidate(word, true, pat, &opts.method(:each)).map(&:first) if pat
 if /\A=/ =~ opt.arg
 opts.map! {|sw| sw + "="}
 if arg and CompletingHash === opt.pattern
 if opts = opt.pattern.candidate(arg, false, argpat)
 opts.map!(&:last)
 end
 end
 end
 list.concat(opts)
 end
 list
end

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

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

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

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

params = ARGV.getopts("ab:", "foo", "bar:")
# params[:a] = true # -a
# params[:b] = "1" # -b1
# params[:foo] = "1" # --foo
# params[:bar] = "x" # --bar x

# File lib/optparse.rb, line 1467
def getopts(*args)
 argv = Array === args.first ? args.shift : default_argv
 single_options, *long_options = *args
 result = {}
 single_options.scan(/(.)(:)?/) do |opt, val|
 if val
 result[opt] = nil
 define("-#{opt} VAL")
 else
 result[opt] = false
 define("-#{opt}")
 end
 end if single_options
 long_options.each do |arg|
 opt, val = arg.split(':', 2)
 if val
 result[opt] = val.empty? ? nil : val
 define("--#{opt} VAL")
 else
 result[opt] = false
 define("--#{opt}")
 end
 end
 parse_in_order(argv, result.method(:[]=))
 result
end

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

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

# File lib/optparse.rb, line 1585
def load(filename = nil)
 begin
 filename ||= File.expand_path(File.basename(0ドル, '.*'), '~/.options')
 rescue
 return false
 end
 begin
 parse(*IO.readlines(filename).each {|s| s.chomp!})
 true
 rescue Errno::ENOENT, Errno::ENOTDIR
 false
 end
end

# File lib/optparse.rb, line 1150
def make_switch(opts, block = nil)
 short, long, nolong, style, pattern, conv, not_pattern, not_conv, not_style = [], [], []
 ldesc, sdesc, desc, arg = [], [], []
 default_style = Switch::NoArgument
 default_pattern = nil
 klass = nil
 q, a = nil
 opts.each do |o|
 # argument class
 next if search(:atype, o) do |pat, c|
 klass = notwice(o, klass, 'type')
 if not_style and not_style != Switch::NoArgument
 not_pattern, not_conv = pat, c
 else
 default_pattern, conv = pat, c
 end
 end
 # directly specified pattern(any object possible to match)
 if (!(String === o || Symbol === o)) and o.respond_to?(:match)
 pattern = notwice(o, pattern, 'pattern')
 if pattern.respond_to?(:convert)
 conv = pattern.method(:convert).to_proc
 else
 conv = SPLAT_PROC
 end
 next
 end
 # anything others
 case o
 when Proc, Method
 block = notwice(o, block, 'block')
 when Array, Hash
 case pattern
 when CompletingHash
 when nil
 pattern = CompletingHash.new
 conv = pattern.method(:convert).to_proc if pattern.respond_to?(:convert)
 else
 raise ArgumentError, "argument pattern given twice"
 end
 o.each {|pat, *v| pattern[pat] = v.fetch(0) {pat}}
 when Module
 raise ArgumentError, "unsupported argument type: #{o}", ParseError.filter_backtrace(caller(4))
 when *ArgumentStyle.keys
 style = notwice(ArgumentStyle[o], style, 'style')
 when /^--no-([^\[\]=\s]*)(.+)?/
 q, a = 1ドル, 2ドル
 o = notwice(a ? Object : TrueClass, klass, 'type')
 not_pattern, not_conv = search(:atype, o) unless not_style
 not_style = (not_style || default_style).guess(arg = a) if a
 default_style = Switch::NoArgument
 default_pattern, conv = search(:atype, FalseClass) unless default_pattern
 ldesc << "--no-#{q}"
 long << 'no-' + (q = q.downcase)
 nolong << q
 when /^--\[no-\]([^\[\]=\s]*)(.+)?/
 q, a = 1ドル, 2ドル
 o = notwice(a ? Object : TrueClass, klass, 'type')
 if a
 default_style = default_style.guess(arg = a)
 default_pattern, conv = search(:atype, o) unless default_pattern
 end
 ldesc << "--[no-]#{q}"
 long << (o = q.downcase)
 not_pattern, not_conv = search(:atype, FalseClass) unless not_style
 not_style = Switch::NoArgument
 nolong << 'no-' + o
 when /^--([^\[\]=\s]*)(.+)?/
 q, a = 1ドル, 2ドル
 if a
 o = notwice(NilClass, klass, 'type')
 default_style = default_style.guess(arg = a)
 default_pattern, conv = search(:atype, o) unless default_pattern
 end
 ldesc << "--#{q}"
 long << (o = q.downcase)
 when /^-(\[\^?\]?(?:[^\\]]|\.)*\])(.+)?/
 q, a = 1ドル, 2ドル
 o = notwice(Object, klass, 'type')
 if a
 default_style = default_style.guess(arg = a)
 default_pattern, conv = search(:atype, o) unless default_pattern
 end
 sdesc << "-#{q}"
 short << Regexp.new(q)
 when /^-(.)(.+)?/
 q, a = 1ドル, 2ドル
 if a
 o = notwice(NilClass, klass, 'type')
 default_style = default_style.guess(arg = a)
 default_pattern, conv = search(:atype, o) unless default_pattern
 end
 sdesc << "-#{q}"
 short << q
 when /^=/
 style = notwice(default_style.guess(arg = o), style, 'style')
 default_pattern, conv = search(:atype, Object) unless default_pattern
 else
 desc.push(o)
 end
 end
 default_pattern, conv = search(:atype, default_style.pattern) unless default_pattern
 if !(short.empty? and long.empty?)
 s = (style || default_style).new(pattern || default_pattern,
 conv, sdesc, ldesc, arg, desc, block)
 elsif !block
 if style or pattern
 raise ArgumentError, "no switch given", ParseError.filter_backtrace(caller)
 end
 s = desc
 else
 short << pattern
 s = (style || default_style).new(pattern,
 conv, nil, nil, arg, desc, block)
 end
 return s, short, long,
 (not_style.new(not_pattern, not_conv, sdesc, ldesc, nil, desc, block) if not_style),
 nolong
end

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

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

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

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

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

# File lib/optparse.rb, line 1339
def order!(argv = default_argv, &nonopt)
 parse_in_order(argv, &nonopt)
end

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

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

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

# File lib/optparse.rb, line 1430
def permute!(argv = default_argv)
 nonopts = []
 order!(argv, &nonopts.method(:<<))
 argv[0, 0] = nonopts
 argv
end

# File lib/optparse.rb, line 967
def program_name
 @program_name || File.basename(0ドル, '.*')
end

reject(t)

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

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

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

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

# File lib/optparse.rb, line 1057
def summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk)
 blk ||= proc {|l| to << (l.index($/, -1) ? l : l + $/)}
 visit(:summarize, {}, {}, width, max, indent, &blk)
 to
end

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

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

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

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

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

Calls superclass method Kernel#warn

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

# File lib/optparse.rb, line 1537
def complete(typ, opt, icase = false, *pat)
 if pat.empty?
 search(typ, opt) {|sw| return [sw, opt]} # exact match or...
 end
 raise AmbiguousOption, catch(:ambiguous) {
 visit(:complete, typ, opt, icase, *pat) {|o, *sw| return sw}
 raise InvalidOption, opt
 }
end

# File lib/optparse.rb, line 1082
def notwice(obj, prv, msg)
 unless !prv or prv == obj
 raise(ArgumentError, "argument #{msg} given twice: #{obj}",
 ParseError.filter_backtrace(caller(2)))
 end
 obj
end

# File lib/optparse.rb, line 1520
def search(id, key)
 block_given = block_given?
 visit(:search, id, key) do |k|
 return block_given ? yield(k) : k
 end
end

# File lib/optparse.rb, line 1509
def visit(id, *args, &block)
 @stack.reverse_each do |el|
 el.send(id, *args, &block)
 end
 nil
end