Class: OptionParser
- Inherits:
-
Object
- Object
- OptionParser
- Defined in:
- lib/optparse/version.rb,
lib/rubysl/optparse/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
-
The argument specification and the code to handle it are written in the same place.
-
It can output an option summary; you don’t need to maintain this string separately.
-
Optional and mandatory arguments are specified very gracefully.
-
Arguments can be automatically converted to a specified class.
-
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'
= {}
OptionParser.new do |opts|
opts. = "Usage: example.rb [options]"
opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
[:verbose] = v
end
end.parse!
p
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.
= OpenStruct.new
.library = []
.inplace = false
.encoding = "utf8"
.transfer_type = :auto
.verbose = false
opt_parser = OptionParser.new do |opts|
opts. = "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|
.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|
.inplace = true
.extension = ext || ''
.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|
.delay = n
end
# Cast 'time' argument to a Time object.
opts.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
.time = time
end
# Cast to octal integer.
opts.on("-F", "--irs [OCTAL]", OptionParser::OctalInteger,
"Specify record separator (default \\0)") do |rs|
.record_separator = rs
end
# List of arguments.
opts.on("--list x,y,z", Array, "Example 'list' of arguments") do |list|
.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|
.encoding = encoding
end
# Optional argument with keyword completion.
opts.on("--type [TYPE]", [:text, :binary, :auto],
"Select transfer type (text, binary, auto)") do |t|
.transfer_type = t
end
# Boolean switch.
opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
.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
opt_parser.parse!(args)
end # parse()
end # class OptparseExample
= OptparseExample.parse(ARGV)
pp
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.
Direct Known Subclasses
Defined Under Namespace
Modules: Acceptables, Arguable, Completion Classes: AC, AmbiguousArgument, AmbiguousOption, CompletingHash, InvalidArgument, InvalidOption, List, MissingArgument, NeedlessArgument, OptionMap, ParseError, Switch
Constant Summary collapse
- RCSID =
:stopdoc:
%w$Id$[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
- COMPSYS_HEADER =
:nodoc:
<<'XXX' # :nodoc: typeset -A opt_args local context state line _argume
- 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
-
#banner ⇒ Object
Heading banner preceding summary.
-
#default_argv ⇒ Object
Strings to be parsed in default.
-
#program_name ⇒ Object
Program name to be emitted in error message and default banner, defaults to $0.
-
#release ⇒ Object
Release code.
-
#summary_indent ⇒ Object
Indentation for summary.
-
#summary_width ⇒ Object
Width for option list portion of summary.
-
#version ⇒ Object
Version.
Class Method Summary collapse
-
.accept(*args, &blk) ⇒ Object
See #accept.
- .each_const(path, base = ::Object) ⇒ Object
-
.getopts(*args) ⇒ Object
See #getopts.
-
.inc(arg, default = nil) ⇒ Object
Returns an incremented value of
default
according toarg
. -
.reject(*args, &blk) ⇒ Object
See #reject.
- .search_const(klass, name) ⇒ Object
- .show_version(*pkgs) ⇒ Object
- .terminate(arg = nil) ⇒ Object
- .top ⇒ Object
-
.with(*args, &block) ⇒ Object
Initializes a new instance and evaluates the optional block in context of the instance.
Instance Method Summary collapse
- #abort(mesg = $!) ⇒ Object
-
#accept(*args, &blk) ⇒ Object
Directs to accept specified class
t
. -
#add_officious ⇒ Object
:nodoc:.
-
#base ⇒ Object
Subject of #on_tail.
- #candidate(word) ⇒ Object
-
#compsys(to, name = File.basename($0)) ⇒ Object
:nodoc:.
- #define(*opts, &block) ⇒ Object (also: #def_option)
- #define_head(*opts, &block) ⇒ Object (also: #def_head_option)
- #define_tail(*opts, &block) ⇒ Object (also: #def_tail_option)
-
#environment(env = File.basename($0, '.*')) ⇒ Object
Parses environment variable
env
or its uppercase with splitting like a shell. -
#getopts(*args) ⇒ Object
Wrapper method for getopts.rb.
-
#help ⇒ Object
(also: #to_s)
Returns option summary string.
- #inc(*args) ⇒ Object
-
#initialize(banner = nil, width = 32, indent = ' ' * 4) {|_self| ... } ⇒ OptionParser
constructor
Initializes the instance and yields itself if called with a block.
-
#load(filename = nil) ⇒ Object
Loads options from file names as
filename
. -
#make_switch(opts, block = nil) ⇒ Object
Creates an OptionParser::Switch from the parameters.
-
#new ⇒ Object
Pushes a new List.
-
#on(*opts, &block) ⇒ Object
Add option switch and handler.
-
#on_head(*opts, &block) ⇒ Object
Add option switch like with #on, but at head of summary.
-
#on_tail(*opts, &block) ⇒ Object
Add option switch like with #on, but at tail of summary.
-
#order(*argv, &block) ⇒ Object
Parses command line arguments
argv
in order. -
#order!(argv = default_argv, &nonopt) ⇒ Object
Same as #order, but removes switches destructively.
-
#parse(*argv) ⇒ Object
Parses command line arguments
argv
in order when environment variable POSIXLY_CORRECT is set, and in permutation mode otherwise. -
#parse!(argv = default_argv) ⇒ Object
Same as #parse, but removes switches destructively.
-
#permute(*argv) ⇒ Object
Parses command line arguments
argv
in permutation mode and returns list of non-option arguments. -
#permute!(argv = default_argv) ⇒ Object
Same as #permute, but removes switches destructively.
-
#reject(*args, &blk) ⇒ Object
Directs to reject specified class argument.
-
#remove ⇒ Object
Removes the last List.
-
#separator(string) ⇒ Object
Add separator in summary.
-
#summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk) ⇒ Object
Puts option summary into
to
and returnsto
. -
#terminate(arg = nil) ⇒ Object
Terminates option parsing.
-
#to_a ⇒ Object
Returns option summary list.
-
#top ⇒ Object
Subject of #on / #on_head, #accept / #reject.
-
#ver ⇒ Object
Returns version string from program_name, version and release.
- #warn(mesg = $!) ⇒ Object
Constructor Details
#initialize(banner = nil, width = 32, indent = ' ' * 4) {|_self| ... } ⇒ OptionParser
Initializes the instance and yields itself if called with a block.
banner
-
Banner message.
width
-
Summary width.
indent
-
Summary indent.
877 878 879 880 881 882 883 884 885 886 |
# File 'lib/rubysl/optparse/optparse.rb', line 877 def initialize( = nil, width = 32, indent = ' ' * 4) @stack = [DefaultList, List.new, List.new] @program_name = nil @banner = @summary_width = width @summary_indent = indent @default_argv = ARGV add_officious yield self if block_given? end |
Instance Attribute Details
#banner ⇒ Object
Heading banner preceding summary.
960 961 962 963 964 965 966 |
# File 'lib/rubysl/optparse/optparse.rb', line 960 def unless @banner @banner = "Usage: #{program_name} [options]" visit(:add_banner, @banner) end @banner end |
#default_argv ⇒ Object
Strings to be parsed in default.
955 956 957 |
# File 'lib/rubysl/optparse/optparse.rb', line 955 def default_argv @default_argv end |
#program_name ⇒ Object
Program name to be emitted in error message and default banner, defaults to $0.
972 973 974 |
# File 'lib/rubysl/optparse/optparse.rb', line 972 def program_name @program_name || File.basename($0, '.*') end |
#release ⇒ Object
Release code
997 998 999 |
# File 'lib/rubysl/optparse/optparse.rb', line 997 def release @release || (defined?(::Release) && ::Release) || (defined?(::RELEASE) && ::RELEASE) end |
#summary_indent ⇒ Object
Indentation for summary. Must be String (or have + String method).
952 953 954 |
# File 'lib/rubysl/optparse/optparse.rb', line 952 def summary_indent @summary_indent end |
#summary_width ⇒ Object
Width for option list portion of summary. Must be Numeric.
949 950 951 |
# File 'lib/rubysl/optparse/optparse.rb', line 949 def summary_width @summary_width end |
Class Method Details
.accept(*args, &blk) ⇒ Object
See #accept.
922 |
# File 'lib/rubysl/optparse/optparse.rb', line 922 def self.accept(*args, &blk) top.accept(*args, &blk) end |
.each_const(path, base = ::Object) ⇒ 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 |
.getopts(*args) ⇒ Object
See #getopts.
1506 1507 1508 |
# File 'lib/rubysl/optparse/optparse.rb', line 1506 def self.getopts(*args) new.getopts(*args) end |
.inc(arg, default = nil) ⇒ Object
Returns an incremented value of default
according to arg
.
858 859 860 861 862 863 864 865 |
# File 'lib/rubysl/optparse/optparse.rb', line 858 def self.inc(arg, default = nil) case arg when Integer arg.nonzero? when nil default.to_i + 1 end end |
.reject(*args, &blk) ⇒ Object
See #reject.
935 |
# File 'lib/rubysl/optparse/optparse.rb', line 935 def self.reject(*args, &blk) top.reject(*args, &blk) end |
.search_const(klass, name) ⇒ Object
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 |
.show_version(*pkgs) ⇒ Object
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..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) ⇒ Object
902 903 904 |
# File 'lib/rubysl/optparse/optparse.rb', line 902 def self.terminate(arg = nil) throw :terminate, arg end |
.top ⇒ Object
907 |
# File 'lib/rubysl/optparse/optparse.rb', line 907 def self.top() DefaultList end |
.with(*args, &block) ⇒ Object
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.
849 850 851 852 853 |
# File 'lib/rubysl/optparse/optparse.rb', line 849 def self.with(*args, &block) opts = new(*args) opts.instance_eval(&block) opts end |
Instance Method Details
#abort(mesg = $!) ⇒ Object
1016 1017 1018 |
# File 'lib/rubysl/optparse/optparse.rb', line 1016 def abort(mesg = $!) super("#{program_name}: #{mesg}") end |
#accept(*args, &blk) ⇒ Object
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)
918 |
# File 'lib/rubysl/optparse/optparse.rb', line 918 def accept(*args, &blk) top.accept(*args, &blk) end |
#add_officious ⇒ Object
:nodoc:
888 889 890 891 892 893 |
# File 'lib/rubysl/optparse/optparse.rb', line 888 def add_officious # :nodoc: list = base() Officious.each do |opt, block| list.long[opt] ||= block.call(self) end end |
#base ⇒ Object
Subject of #on_tail.
1030 1031 1032 |
# File 'lib/rubysl/optparse/optparse.rb', line 1030 def base @stack[1] end |
#candidate(word) ⇒ Object
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 |
# File 'lib/rubysl/optparse/optparse.rb', line 1553 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 |
#compsys(to, name = File.basename($0)) ⇒ Object
:nodoc:
766 767 768 769 770 771 772 773 |
# File 'lib/rubysl/optparse/optparse.rb', line 766 def compsys(to, name = File.basename($0)) # :nodoc: to << "#compdef #{name}\n" to << COMPSYS_HEADER visit(:compsys, {}, {}) {|o, d| to << %Q[ "#{o}[#{d.gsub(/[\"\[\]]/, '\\\\\&')}]" \\\n] } to << " '*:file:_files' && return 0\n" end |
#define(*opts, &block) ⇒ Object Also known as: def_option
1279 1280 1281 1282 |
# File 'lib/rubysl/optparse/optparse.rb', line 1279 def define(*opts, &block) top.append(*(sw = make_switch(opts, block))) sw[0] end |
#define_head(*opts, &block) ⇒ Object Also known as: def_head_option
1294 1295 1296 1297 |
# File 'lib/rubysl/optparse/optparse.rb', line 1294 def define_head(*opts, &block) top.prepend(*(sw = make_switch(opts, block))) sw[0] end |
#define_tail(*opts, &block) ⇒ Object Also known as: def_tail_option
1308 1309 1310 1311 |
# File 'lib/rubysl/optparse/optparse.rb', line 1308 def define_tail(*opts, &block) base.append(*(sw = make_switch(opts, block))) sw[0] end |
#environment(env = File.basename($0, '.*')) ⇒ Object
Parses environment variable env
or its uppercase with splitting like a shell.
env
defaults to the basename of the program.
1610 1611 1612 1613 1614 |
# File 'lib/rubysl/optparse/optparse.rb', line 1610 def environment(env = File.basename($0, '.*')) env = ENV[env] || ENV[env.upcase] or return require 'shellwords' parse(*Shellwords.shellwords(env)) end |
#getopts(*args) ⇒ Object
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
1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 |
# File 'lib/rubysl/optparse/optparse.rb', line 1472 def getopts(*args) argv = Array === args.first ? args.shift : default_argv , * = *args result = {} .scan(/(.)(:)?/) do |opt, val| if val result[opt] = nil define("-#{opt} VAL") else result[opt] = false define("-#{opt}") end end if .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 |
#help ⇒ Object Also known as: to_s
Returns option summary string.
1071 |
# File 'lib/rubysl/optparse/optparse.rb', line 1071 def help; summarize("#{}".sub(/\n?\z/, "\n")) end |
#inc(*args) ⇒ Object
866 867 868 |
# File 'lib/rubysl/optparse/optparse.rb', line 866 def inc(*args) self.class.inc(*args) end |
#load(filename = nil) ⇒ Object
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.
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 |
# File 'lib/rubysl/optparse/optparse.rb', line 1590 def load(filename = nil) begin filename ||= File.(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) ⇒ Object
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.
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 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 |
# File 'lib/rubysl/optparse/optparse.rb', line 1155 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 ⇒ Object
Pushes a new List.
1037 1038 1039 1040 1041 1042 1043 1044 |
# File 'lib/rubysl/optparse/optparse.rb', line 1037 def new @stack.push(List.new) if block_given? yield self else self end end |
#on(*opts, &block) ⇒ Object
Add option switch and handler. See #make_switch for an explanation of parameters.
1288 1289 1290 1291 |
# File 'lib/rubysl/optparse/optparse.rb', line 1288 def on(*opts, &block) define(*opts, &block) self end |
#on_head(*opts, &block) ⇒ Object
Add option switch like with #on, but at head of summary.
1302 1303 1304 1305 |
# File 'lib/rubysl/optparse/optparse.rb', line 1302 def on_head(*opts, &block) define_head(*opts, &block) self end |
#on_tail(*opts, &block) ⇒ Object
Add option switch like with #on, but at tail of summary.
1316 1317 1318 1319 |
# File 'lib/rubysl/optparse/optparse.rb', line 1316 def on_tail(*opts, &block) define_tail(*opts, &block) self end |
#order(*argv, &block) ⇒ Object
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.
1335 1336 1337 1338 |
# File 'lib/rubysl/optparse/optparse.rb', line 1335 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) ⇒ Object
Same as #order, but removes switches destructively. Non-option arguments remain in argv
.
1344 1345 1346 |
# File 'lib/rubysl/optparse/optparse.rb', line 1344 def order!(argv = default_argv, &nonopt) parse_in_order(argv, &nonopt) end |
#parse(*argv) ⇒ Object
Parses command line arguments argv
in order when environment variable POSIXLY_CORRECT is set, and in permutation mode otherwise.
1446 1447 1448 1449 |
# File 'lib/rubysl/optparse/optparse.rb', line 1446 def parse(*argv) argv = argv[0].dup if argv.size == 1 and Array === argv[0] parse!(argv) end |
#parse!(argv = default_argv) ⇒ Object
Same as #parse, but removes switches destructively. Non-option arguments remain in argv
.
1455 1456 1457 1458 1459 1460 1461 |
# File 'lib/rubysl/optparse/optparse.rb', line 1455 def parse!(argv = default_argv) if ENV.include?('POSIXLY_CORRECT') order!(argv) else permute!(argv) end end |
#permute(*argv) ⇒ Object
Parses command line arguments argv
in permutation mode and returns list of non-option arguments.
1426 1427 1428 1429 |
# File 'lib/rubysl/optparse/optparse.rb', line 1426 def permute(*argv) argv = argv[0].dup if argv.size == 1 and Array === argv[0] permute!(argv) end |
#permute!(argv = default_argv) ⇒ Object
Same as #permute, but removes switches destructively. Non-option arguments remain in argv
.
1435 1436 1437 1438 1439 1440 |
# File 'lib/rubysl/optparse/optparse.rb', line 1435 def permute!(argv = default_argv) nonopts = [] order!(argv, &nonopts.method(:<<)) argv[0, 0] = nonopts argv end |
#reject(*args, &blk) ⇒ Object
Directs to reject specified class argument.
t
-
Argument class specifier, any object including Class.
reject(t)
931 |
# File 'lib/rubysl/optparse/optparse.rb', line 931 def reject(*args, &blk) top.reject(*args, &blk) end |
#remove ⇒ Object
Removes the last List.
1049 1050 1051 |
# File 'lib/rubysl/optparse/optparse.rb', line 1049 def remove @stack.pop end |
#separator(string) ⇒ Object
Add separator in summary.
1325 1326 1327 |
# File 'lib/rubysl/optparse/optparse.rb', line 1325 def separator(string) top.append(string, nil, nil) end |
#summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk) ⇒ Object
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.
1062 1063 1064 1065 1066 |
# File 'lib/rubysl/optparse/optparse.rb', line 1062 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) ⇒ Object
Terminates option parsing. Optional parameter arg
is a string pushed back to be the first non-option argument.
899 900 901 |
# File 'lib/rubysl/optparse/optparse.rb', line 899 def terminate(arg = nil) self.class.terminate(arg) end |
#to_a ⇒ Object
Returns option summary list.
1077 |
# File 'lib/rubysl/optparse/optparse.rb', line 1077 def to_a; summarize("#{}".split(/^/)) end |
#top ⇒ Object
Subject of #on / #on_head, #accept / #reject
1023 1024 1025 |
# File 'lib/rubysl/optparse/optparse.rb', line 1023 def top @stack[-1] end |
#ver ⇒ Object
Returns version string from program_name, version and release.
1004 1005 1006 1007 1008 1009 1010 |
# File 'lib/rubysl/optparse/optparse.rb', line 1004 def ver if v = version str = "#{program_name} #{[v].join('.')}" str << " (#{v})" if v = release str end end |
#warn(mesg = $!) ⇒ Object
1012 1013 1014 |
# File 'lib/rubysl/optparse/optparse.rb', line 1012 def warn(mesg = $!) super("#{program_name}: #{mesg}") end |