ÿØÿà JFIF ÿÛ „ ( % !1!%)+//. 383,7(-.+
-% %-////---/-.+/--+------/------/--0+--/-/-----.-----ÿÀ ¥2" ÿÄ ÿÄ J ! 1AQ"aq2‘#BR‚¡ÁÑ3br’¢±Âð$CSƒ²á4c“%DsÓñÿÄ ÿÄ * !1AQa‘"2q3±ð#b¡ÿÚ ? ¼QxJQa Íuò¸Zö Úü8,Ð Úú
"SS n<rçù–´âE—^ªBÖ9À\†¸ÔÁTÃÛ5
ëd´³Í#Ý;Þ38œî ¶ H£M:wÎ3…³…âpÔF&‚FK¸9„â4àGEõªfÿ ‘ñ(ß wpŽF|È¥ù®häðÍѶ¹‘[ÒinÙW¶ùñ Y˜Q{›K"išÒ[Ú8žë\F¹@-? v"ÔU”,ìöžkÿ {I‡£šÍ?e
ríV
?>
.........................................
.............................................................................
ÿØÿà JFIF ÿÛ „
(
% !1!%)+//. 383,7(-.+
-% %-////---/-.+/--+------/------/--0+--/-/-----.-----ÿÀ ¥2" ÿÄ
ÿÄ J ! 1AQ"aq2‘#BR‚¡ÁÑ3br’¢±Âð$CSƒ²á4c“%DsÓñÿÄ
ÿÄ * !1AQa‘"2q3±ð#b¡ÿÚ
? ¼QxJQa Íuò¸Zö
Úü8,Ð Úú
"SS n<rçù–´âE—^ªBÖ9À\†¸ÔÁTÃÛ5
ëd´³Í#Ý;Þ38œî ¶ H£M:wÎ3…³…âpÔF&‚FK¸9„â4àGEõªfÿ ‘ñ(ß wpŽF|È¥ù®häðÍѶ¹‘[ÒinÙW¶ùñ Y˜Q{›K"išÒ[Ú8žë\F¹@-? v"ÔU”,ìöžkÿ {I‡£šÍ?e
ríV
?>
.........................................
.............................................................................
????????????????????????????????????
????????????????????????????????????
ÿØÿà JFIF ÿÛ „ ( % !1!%)+//. 383,7(-.+
-% %-////---/-.+/--+------/------/--0+--/-/-----.-----ÿÀ ¥2" ÿÄ ÿÄ J ! 1AQ"aq2‘#BR‚¡ÁÑ3br’¢±Âð$CSƒ²á4c“%DsÓñÿÄ ÿÄ * !1AQa‘"2q3±ð#b¡ÿÚ ? ¼QxJQa Íuò¸Zö Úü8,Ð Úú
"SS n<rçù–´âE—^ªBÖ9À\†¸ÔÁTÃÛ5
ëd´³Í#Ý;Þ38œî ¶ H£M:wÎ3…³…âpÔF&‚FK¸9„â4àGEõªfÿ ‘ñ(ß wpŽF|È¥ù®häðÍѶ¹‘[ÒinÙW¶ùñ Y˜Q{›K"išÒ[Ú8žë\F¹@-? v"ÔU”,ìöžkÿ {I‡£šÍ?e
ríV
?>
.........................................
.............................................................................
ÿØÿà JFIF ÿÛ „
(
% !1!%)+//. 383,7(-.+
-% %-////---/-.+/--+------/------/--0+--/-/-----.-----ÿÀ ¥2" ÿÄ
ÿÄ J ! 1AQ"aq2‘#BR‚¡ÁÑ3br’¢±Âð$CSƒ²á4c“%DsÓñÿÄ
ÿÄ * !1AQa‘"2q3±ð#b¡ÿÚ
? ¼QxJQa Íuò¸Zö
Úü8,Ð Úú
"SS n<rçù–´âE—^ªBÖ9À\†¸ÔÁTÃÛ5
ëd´³Í#Ý;Þ38œî ¶ H£M:wÎ3…³…âpÔF&‚FK¸9„â4àGEõªfÿ ‘ñ(ß wpŽF|È¥ù®häðÍѶ¹‘[ÒinÙW¶ùñ Y˜Q{›K"išÒ[Ú8žë\F¹@-? v"ÔU”,ìöžkÿ {I‡£šÍ?e
ríV
?>
.........................................
.............................................................................
????????????????????????????????????
????????????????????????????????????
U:RDoc::TopLevel[ i I"optparse/tutorial.rdoc:ETcRDoc::Parser::Simpleo:RDoc::Markup::Document: @parts[|S:RDoc::Markup::Heading:
leveli: textI"
Tutorial;To: RDoc::Markup::BlankLine S; ;
i; I"Why +OptionParser+?;T@
o: RDoc::Markup::Paragraph;[I"JWhen a Ruby program executes, it captures its command-line arguments ;TI"%and options into variable ARGV. ;TI"0This simple program just prints its +ARGV+:;T@
o:RDoc::Markup::Verbatim;[I" p ARGV
;T: @format0o;
;[I"+Execution, with arguments and options:;T@
o;;[I",$ ruby argv.rb foo --bar --baz bat bam
;TI"-["foo", "--bar", "--baz", "bat", "bam"]
;T;0o;
;[I"CThe executing program is responsible for parsing and handling ;TI" the command-line options.;T@
o;
;[I"HOptionParser offers methods for parsing and handling those options.;T@
o;
;[I"IWith +OptionParser+, you can define options so that for each option:;T@
o:RDoc::Markup::List:
@type: BULLET: @items[
o:RDoc::Markup::ListItem: @label0;[o;
;[I"HThe code that defines the option and code that handles that option ;TI"are in the same place.;To;;0;[o;
;[I"SThe option may take no argument, a required argument, or an optional argument.;To;;0;[o;
;[I"FThe argument may be automatically converted to a specified class.;To;;0;[o;
;[I"9The argument may be restricted to specified _forms_.;To;;0;[o;
;[I":The argument may be restricted to specified _values_.;T@
o;
;[I"WThe class also has method #help, which displays automatically-generated help text.;T@
S; ;
i; I"
Contents;T@
o;;;;[o;;0;[o;
;[I"*{To Begin With}[#label-To+Begin+With];To;;0;[o;
;[I"0{Defining Options}[#label-Defining+Options];To;;0;[o;
;[I"({Option Names}[#label-Option+Names];To;;;;[ o;;0;[o;
;[I"4{Short Option Names}[#label-Short+Option+Names];To;;0;[o;
;[I"2{Long Option Names}[#label-Long+Option+Names];To;;0;[o;
;[I"6{Mixing Option Names}[#label-Mixing+Option+Names];To;;0;[o;
;[I"B{Option Name Abbreviations}[#label-Option+Name+Abbreviations];To;;0;[o;
;[I"0{Option Arguments}[#label-Option+Arguments];To;;;;[ o;;0;[o;
;[I">{Option with No Argument}[#label-Option+with+No+Argument];To;;0;[o;
;[I"J{Option with Required Argument}[#label-Option+with+Required+Argument];To;;0;[o;
;[I"J{Option with Optional Argument}[#label-Option+with+Optional+Argument];To;;0;[o;
;[I"<{Argument Abbreviations}[#label-Argument+Abbreviations];To;;0;[o;
;[I".{Argument Values}[#label-Argument+Values];To;;;;[o;;0;[o;
;[I"@{Explicit Argument Values}[#label-Explicit+Argument+Values];To;;;;[o;;0;[o;
;[I"@{Explicit Values in Array}[#label-Explicit+Values+in+Array];To;;0;[o;
;[I">{Explicit Values in Hash}[#label-Explicit+Values+in+Hash];To;;0;[o;
;[I">{Argument Value Patterns}[#label-Argument+Value+Patterns];To;;0;[o;
;[I":{Keyword Argument into}[#label-Keyword+Argument+into];To;;;;[o;;0;[o;
;[I"4{Collecting Options}[#label-Collecting+Options];To;;0;[o;
;[I"H{Checking for Missing Options}[#label-Checking+for+Missing+Options];To;;0;[o;
;[I"D{Default Values for Options}[#label-Default+Values+for+Options];To;;0;[o;
;[I"6{Argument Converters}[#label-Argument+Converters];To;;0;[o;
;[I"{Help}[#label-Help];To;;0;[o;
;[I"<{Top List and Base List}[#label-Top+List+and+Base+List];To;;0;[o;
;[I"H{Methods for Defining Options}[#label-Methods+for+Defining+Options];To;;0;[o;
;[I" {Parsing}[#label-Parsing];To;;;;[ o;;0;[o;
;[I",{Method parse!}[#label-Method+parse-21];To;;0;[o;
;[I"({Method parse}[#label-Method+parse];To;;0;[o;
;[I",{Method order!}[#label-Method+order-21];To;;0;[o;
;[I"({Method order}[#label-Method+order];To;;0;[o;
;[I"0{Method permute!}[#label-Method+permute-21];To;;0;[o;
;[I",{Method permute}[#label-Method+permute];T@
S; ;
i; I"To Begin With;T@
o;
;[I"To use +OptionParser+:;T@
o;;: NUMBER;[ o;;0;[o;
;[I"%Require the +OptionParser+ code.;To;;0;[o;
;[I"%Create an +OptionParser+ object.;To;;0;[o;
;[I" Define one or more options.;To;;0;[o;
;[I" Parse the command line.;T@
o;
;[I"9File +basic.rb+ defines three options, -x, ;TI"C-y, and -z, each with a descriptive string, ;TI"and each with a block.;T@
o;;[I"&# Require the OptionParser code.
;TI"require 'optparse'
;TI"&# Create an OptionParser object.
;TI" parser = OptionParser.new
;TI"## Define one or more options.
;TI"0parser.on('-x', 'Whether to X') do |value|
;TI" p ['x', value]
;TI" end
;TI"0parser.on('-y', 'Whether to Y') do |value|
;TI" p ['y', value]
;TI" end
;TI"0parser.on('-z', 'Whether to Z') do |value|
;TI" p ['z', value]
;TI" end
;TI":# Parse the command line and return pared-down ARGV.
;TI"p parser.parse!
;T;0o;
;[I"KFrom these defined options, the parser automatically builds help text:;T@
o;;[
I" $ ruby basic.rb --help
;TI" Usage: basic [options]
;TI"7 -x Whether to X
;TI"7 -y Whether to Y
;TI"7 -z Whether to Z
;T;0o;
;[I"-When an option is found during parsing, ;TI"Ithe block defined for the option is called with the argument value. ;TI"+An invalid option raises an exception.;T@
o;
;[ I"@Method #parse!, which is used most often in this tutorial, ;TI"=removes from +ARGV+ the options and arguments it finds, ;TI"Nleaving other non-option arguments for the program to handle on its own. ;TI":The method returns the possibly-reduced +ARGV+ array.;T@
o;
;[I"Executions:;T@
o;;[I"$ ruby basic.rb -x -z
;TI"["x", true]
;TI"["z", true]
;TI"[]
;TI" $ ruby basic.rb -z -y -x
;TI"["z", true]
;TI"["y", true]
;TI"["x", true]
;TI"[]
;TI"7$ ruby basic.rb -x input_file.txt output_file.txt
;TI"["x", true]
;TI"+["input_file.txt", "output_file.txt"]
;TI"$ ruby basic.rb -a
;TI"Obasic.rb:16:in `': invalid option: -a (OptionParser::InvalidOption)
;T;0S; ;
i; I"Defining Options;T@
o;
;[I"8A common way to define an option in +OptionParser+ ;TI"-is with instance method OptionParser#on.;T@
o;
;[I";The method may be called with any number of arguments ;TI"$(whose order does not matter), ;TI"Cand may also have a trailing optional keyword argument +into+.;T@
o;
;[I"JThe given arguments determine the characteristics of the new option. ;TI"These may include:;T@
o;;;;[ o;;0;[o;
;[I"$One or more short option names.;To;;0;[o;
;[I"#One or more long option names.;To;;0;[o;
;[I"XWhether the option takes no argument, an optional argument, or a required argument.;To;;0;[o;
;[I")Acceptable _forms_ for the argument.;To;;0;[o;
;[I"*Acceptable _values_ for the argument.;To;;0;[o;
;[I"IA proc or method to be called when the parser encounters the option.;To;;0;[o;
;[I"(String descriptions for the option.;T@
S; ;
i; I"Option Names;T@
o;
;[I";You can give an option one or more names of two types:;T@
o;;;;[o;;0;[o;
;[I"FShort (1-character) name, beginning with one hyphen (-).;To;;0;[o;
;[I"KLong (multi-character) name, beginning with two hyphens (--).;T@
S; ;
i ; I"Short Option Names;T@
o;
;[I"EA short option name consists of a hyphen and a single character.;T@
o;
;[I"File +short_names.rb+ ;TI"7defines an option with a short name, -x, ;TI"Yand an option with two short names (aliases, in effect) -y and -z.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI".parser.on('-x', 'Short name') do |value|
;TI" p ['x', value]
;TI" end
;TI"9parser.on('-1', '-%', 'Two short names') do |value|
;TI" p ['-1 or -%', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I""$ ruby short_names.rb --help
;TI""Usage: short_names [options]
;TI"5 -x Short name
;TI": -1, -% Two short names
;TI" $ ruby short_names.rb -x
;TI"["x", true]
;TI" $ ruby short_names.rb -1
;TI"["-1 or -%", true]
;TI" $ ruby short_names.rb -%
;TI"["-1 or -%", true]
;T;0o;
;[I"/Multiple short names can "share" a hyphen:;T@
o;;[ I" $ ruby short_names.rb -x1%
;TI"["x", true]
;TI"["-1 or -%", true]
;TI"["-1 or -%", true]
;T;0S; ;
i ; I"Long Option Names;T@
o;
;[I"MA long option name consists of two hyphens and a one or more characters ;TI"&(usually two or more characters).;T@
o;
;[I"File +long_names.rb+ ;TI"9defines an option with a long name, --xxx, ;TI"^and an option with two long names (aliases, in effect) --y1% and --z2#.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI"0parser.on('--xxx', 'Long name') do |value|
;TI" p ['-xxx', value]
;TI" end
;TI">parser.on('--y1%', '--z2#', "Two long names") do |value|
;TI"# p ['--y1% or --z2#', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I"!$ ruby long_names.rb --help
;TI"!Usage: long_names [options]
;TI"4 --xxx Long name
;TI"9 --y1%, --z2# Two long names
;TI" $ ruby long_names.rb --xxx
;TI"["-xxx", true]
;TI" $ ruby long_names.rb --y1%
;TI" ["--y1% or --z2#", true]
;TI" $ ruby long_names.rb --z2#
;TI" ["--y1% or --z2#", true]
;T;0o;
;[I"GA long name may be defined with both positive and negative senses.;T@
o;
;[I"IFile +long_with_negation.rb+ defines an option that has both senses.;T@
o;;[ I"require 'optparse'
;TI" parser = OptionParser.new
;TI"Fparser.on('--[no-]binary', 'Long name with negation') do |value|
;TI" p [value, value.class]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[ I")$ ruby long_with_negation.rb --help
;TI")Usage: long_with_negation [options]
;TI"B --[no-]binary Long name with negation
;TI"+$ ruby long_with_negation.rb --binary
;TI"[true, TrueClass]
;TI".$ ruby long_with_negation.rb --no-binary
;TI"[false, FalseClass]
;T;0S; ;
i ; I"Mixing Option Names;T@
o;
;[I">Many developers like to mix short and long option names, ;TI"Fso that a short name is in effect an abbreviation of a long name.;T@
o;
;[I"File +mixed_names.rb+ ;TI"Adefines options that each have both a short and a long name.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI"Hparser.on('-x', '--xxx', 'Short and long, no argument') do |value|
;TI" p ['--xxx', value]
;TI" end
;TI"Qparser.on('-yYYY', '--yyy', 'Short and long, required argument') do |value|
;TI" p ['--yyy', value]
;TI" end
;TI"Tparser.on('-z [ZZZ]', '--zzz', 'Short and long, optional argument') do |value|
;TI" p ['--zzz', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[ I""$ ruby mixed_names.rb --help
;TI""Usage: mixed_names [options]
;TI"F -x, --xxx Short and long, no argument
;TI"L -y, --yyyYYY Short and long, required argument
;TI"L -z, --zzz [ZZZ] Short and long, optional argument
;TI" $ ruby mixed_names.rb -x
;TI"["--xxx", true]
;TI"!$ ruby mixed_names.rb --xxx
;TI"["--xxx", true]
;TI" $ ruby mixed_names.rb -y
;TI"Ymixed_names.rb:12:in `': missing argument: -y (OptionParser::MissingArgument)
;TI""$ ruby mixed_names.rb -y FOO
;TI"["--yyy", "FOO"]
;TI"!$ ruby mixed_names.rb --yyy
;TI"\mixed_names.rb:12:in `': missing argument: --yyy (OptionParser::MissingArgument)
;TI"%$ ruby mixed_names.rb --yyy BAR
;TI"["--yyy", "BAR"]
;TI" $ ruby mixed_names.rb -z
;TI"["--zzz", nil]
;TI""$ ruby mixed_names.rb -z BAZ
;TI"["--zzz", "BAZ"]
;TI"!$ ruby mixed_names.rb --zzz
;TI"["--zzz", nil]
;TI"%$ ruby mixed_names.rb --zzz BAT
;TI"["--zzz", "BAT"]
;T;0S; ;
i ; I" Option Name Abbreviations;T@
o;
;[I"KBy default, abbreviated option names on the command-line are allowed. ;TI"QAn abbreviated name is valid if it is unique among abbreviated option names.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI".parser.on('-n', '--dry-run',) do |value|
;TI" p ['--dry-run', value]
;TI" end
;TI",parser.on('-d', '--draft',) do |value|
;TI" p ['--draft', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I""$ ruby name_abbrev.rb --help
;TI""Usage: name_abbrev [options]
;TI" -n, --dry-run
;TI" -d, --draft
;TI" $ ruby name_abbrev.rb -n
;TI"["--dry-run", true]
;TI"%$ ruby name_abbrev.rb --dry-run
;TI"["--dry-run", true]
;TI" $ ruby name_abbrev.rb -d
;TI"["--draft", true]
;TI"#$ ruby name_abbrev.rb --draft
;TI"["--draft", true]
;TI" $ ruby name_abbrev.rb --d
;TI"Yname_abbrev.rb:9:in `': ambiguous option: --d (OptionParser::AmbiguousOption)
;TI" $ ruby name_abbrev.rb --dr
;TI"Zname_abbrev.rb:9:in `': ambiguous option: --dr (OptionParser::AmbiguousOption)
;TI"!$ ruby name_abbrev.rb --dry
;TI"["--dry-run", true]
;TI"!$ ruby name_abbrev.rb --dra
;TI"["--draft", true]
;T;0o;
;[I"?You can disable abbreviation using method +require_exact+.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI".parser.on('-n', '--dry-run',) do |value|
;TI" p ['--dry-run', value]
;TI" end
;TI",parser.on('-d', '--draft',) do |value|
;TI" p ['--draft', value]
;TI" end
;TI"!parser.require_exact = true
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[ I"($ ruby no_abbreviation.rb --dry-ru
;TI"_no_abbreviation.rb:10:in `': invalid option: --dry-ru (OptionParser::InvalidOption)
;TI")$ ruby no_abbreviation.rb --dry-run
;TI"["--dry-run", true]
;T;0S; ;
i; I"Option Arguments;T@
o;
;[I"RAn option may take no argument, a required argument, or an optional argument.;T@
S; ;
i ; I" Option with No Argument;T@
o;
;[I"': missing argument: -x (OptionParser::MissingArgument)
;T;0S; ;
i ; I""Option with Optional Argument;T@
o;
;[I"GSpecify an optional argument for an option by adding a dummy word ;TI"8enclosed in square brackets to its name definition.;T@
o;
;[I"6File +optional_argument.rb+ defines two options; ;TI"Zeach has an optional argument because the name definition has a following dummy word ;TI"in square brackets.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI"Tparser.on('-x [XXX]', '--xxx', 'Optional argument via short name') do |value|
;TI" p ['--xxx', value]
;TI" end
;TI"Rparser.on('-y', '--yyy [YYY]', 'Optional argument via long name') do |value|
;TI" p ['--yyy', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"JWhen an option with an argument is found, the given argument yielded.;T@
o;
;[I"Executions:;T@
o;;[
I"($ ruby optional_argument.rb --help
;TI"(Usage: optional_argument [options]
;TI"L -x, --xxx [XXX] Optional argument via short name
;TI"J -y, --yyy [YYY] Optional argument via long name
;TI"($ ruby optional_argument.rb -x AAA
;TI"["--xxx", "AAA"]
;TI"($ ruby optional_argument.rb -y BBB
;TI"["--yyy", "BBB"]
;T;0o;
;[I";Omitting an optional argument does not raise an error.;T@
S; ;
i ; I"Argument Abbreviations;T@
o;
;[I"4Specify an argument list as an Array or a Hash.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI"Vparser.on('-x', '--xxx=VALUE', %w[ABC def], 'Argument abbreviations') do |value|
;TI" p ['--xxx', value]
;TI" end
;TI"eparser.on('-y', '--yyy=VALUE', {"abc"=>"XYZ", def: "FOO"}, 'Argument abbreviations') do |value|
;TI" p ['--yyy', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"DWhen an argument is abbreviated, the expanded argument yielded.;T@
o;
;[I"Executions:;T@
o;;[I",$ ruby argument_abbreviation.rb --help
;TI",Usage: argument_abbreviation [options]
;TI",Usage: argument_abbreviation [options]
;TI"A -x, --xxx=VALUE Argument abbreviations
;TI"A -y, --yyy=VALUE Argument abbreviations
;TI"-$ ruby argument_abbreviation.rb --xxx A
;TI"["--xxx", "ABC"]
;TI"-$ ruby argument_abbreviation.rb --xxx c
;TI"gargument_abbreviation.rb:9:in `': invalid argument: --xxx c (OptionParser::InvalidArgument)
;TI"5$ ruby argument_abbreviation.rb --yyy a --yyy d
;TI"["--yyy", "XYZ"]
;TI"["--yyy", "FOO"]
;T;0S; ;
i; I"Argument Values;T@
o;
;[I"3Permissible argument values may be restricted ;TI"*either by specifying explicit values ;TI"?or by providing a pattern that the given value must match.;T@
S; ;
i ; I" Explicit Argument Values;T@
o;
;[I";You can specify argument values in either of two ways:;T@
o;;;;[o;;0;[o;
;[I"(Specify values an array of strings.;To;;0;[o;
;[I"Specify values a hash.;T@
S; ;
i
; I" Explicit Values in Array;T@
o;
;[I"FYou can specify explicit argument values in an array of strings. ;TI"UThe argument value must be one of those strings, or an unambiguous abbreviation.;T@
o;
;[I"SFile +explicit_array_values.rb+ defines options with explicit argument values.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI"Tparser.on('-xXXX', ['foo', 'bar'], 'Values for required argument' ) do |value|
;TI" p ['-x', value]
;TI" end
;TI"Vparser.on('-y [YYY]', ['baz', 'bat'], 'Values for optional argument') do |value|
;TI" p ['-y', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I",$ ruby explicit_array_values.rb --help
;TI",Usage: explicit_array_values [options]
;TI"G -xXXX Values for required argument
;TI"G -y [YYY] Values for optional argument
;TI"($ ruby explicit_array_values.rb -x
;TI"bexplicit_array_values.rb:9:in `': missing argument: -x (OptionParser::MissingArgument)
;TI",$ ruby explicit_array_values.rb -x foo
;TI"["-x", "foo"]
;TI"*$ ruby explicit_array_values.rb -x f
;TI"["-x", "foo"]
;TI",$ ruby explicit_array_values.rb -x bar
;TI"["-x", "bar"]
;TI"+$ ruby explicit_array_values.rb -y ba
;TI"iexplicit_array_values.rb:9:in `': ambiguous argument: -y ba (OptionParser::AmbiguousArgument)
;TI",$ ruby explicit_array_values.rb -x baz
;TI"fexplicit_array_values.rb:9:in `': invalid argument: -x baz (OptionParser::InvalidArgument)
;T;0S; ;
i
; I" Explicit Values in Hash;T@
o;
;[I"JYou can specify explicit argument values in a hash with string keys. ;TI"QThe value passed must be one of those keys, or an unambiguous abbreviation; ;TI"6the value yielded will be the value for that key.;T@
o;
;[I"RFile +explicit_hash_values.rb+ defines options with explicit argument values.;T@
o;;[I"require 'optparse'
;TI" parser = OptionParser.new
;TI"Vparser.on('-xXXX', {foo: 0, bar: 1}, 'Values for required argument' ) do |value|
;TI" p ['-x', value]
;TI" end
;TI"Xparser.on('-y [YYY]', {baz: 2, bat: 3}, 'Values for optional argument') do |value|
;TI" p ['-y', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[ I"+$ ruby explicit_hash_values.rb --help
;TI"+Usage: explicit_hash_values [options]
;TI"G -xXXX Values for required argument
;TI"G -y [YYY] Values for optional argument
;TI"'$ ruby explicit_hash_values.rb -x
;TI"aexplicit_hash_values.rb:9:in `': missing argument: -x (OptionParser::MissingArgument)
;TI"+$ ruby explicit_hash_values.rb -x foo
;TI"["-x", 0]
;TI")$ ruby explicit_hash_values.rb -x f
;TI"["-x", 0]
;TI"+$ ruby explicit_hash_values.rb -x bar
;TI"["-x", 1]
;TI"+$ ruby explicit_hash_values.rb -x baz
;TI"eexplicit_hash_values.rb:9:in `': invalid argument: -x baz (OptionParser::InvalidArgument)
;TI"'$ ruby explicit_hash_values.rb -y
;TI"["-y", nil]
;TI"+$ ruby explicit_hash_values.rb -y baz
;TI"["-y", 2]
;TI"+$ ruby explicit_hash_values.rb -y bat
;TI"["-y", 3]
;TI"*$ ruby explicit_hash_values.rb -y ba
;TI"hexplicit_hash_values.rb:9:in `': ambiguous argument: -y ba (OptionParser::AmbiguousArgument)
;TI"+$ ruby explicit_hash_values.rb -y bam
;TI"["-y", nil]
;T;0S; ;
i ; I" Argument Value Patterns;T@
o;
;[I"2You can restrict permissible argument values ;TI"?by specifying a Regexp that the given argument must match.;T@
o;
;[I"KFile +matched_values.rb+ defines options with matched argument values.;T@
o;;[ I"require 'optparse'
;TI" parser = OptionParser.new
;TI"Aparser.on('--xxx XXX', /foo/i, 'Matched values') do |value|
;TI" p ['--xxx', value]
;TI" end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I"%$ ruby matched_values.rb --help
;TI"%Usage: matched_values [options]
;TI"9 --xxx XXX Matched values
;TI"($ ruby matched_values.rb --xxx foo
;TI"["--xxx", "foo"]
;TI"($ ruby matched_values.rb --xxx FOO
;TI"["--xxx", "FOO"]
;TI"($ ruby matched_values.rb --xxx bar
;TI"bmatched_values.rb:6:in `': invalid argument: --xxx bar (OptionParser::InvalidArgument)
;T;0S; ;
i; I" Keyword Argument +into+;T@
o;
;[I"VIn parsing options, you can add keyword option +into+ with a hash-like argument; ;TI";each parsed option will be added as a name/value pair.;T@
o;
;[I"This is useful for:;T@
o;;;;[o;;0;[o;
;[I"Collecting options.;To;;0;[o;
;[I""Checking for missing options.;To;;0;[o;
;[I"*Providing default values for options.;T@
S; ;
i ; I"Collecting Options;T@
o;
;[I"4Use keyword argument +into+ to collect options.;T@
o;;[
I"require 'optparse'
;TI" parser = OptionParser.new
;TI"=parser.on('-x', '--xxx', 'Short and long, no argument')
;TI"Fparser.on('-yYYY', '--yyy', 'Short and long, required argument')
;TI"Iparser.on('-z [ZZZ]', '--zzz', 'Short and long, optional argument')
;TI"options = {}
;TI""parser.parse!(into: options)
;TI"p options
;T;0o;
;[I"Executions:;T@
o;;[I"($ ruby collected_options.rb --help
;TI"Usage: into [options]
;TI"F -x, --xxx Short and long, no argument
;TI"L -y, --yyyYYY Short and long, required argument
;TI"L -z, --zzz [ZZZ] Short and long, optional argument
;TI"'$ ruby collected_options.rb --xxx
;TI"{:xxx=>true}
;TI"1$ ruby collected_options.rb --xxx --yyy FOO
;TI" {:xxx=>true, :yyy=>"FOO"}
;TI";$ ruby collected_options.rb --xxx --yyy FOO --zzz Bar
;TI",{:xxx=>true, :yyy=>"FOO", :zzz=>"Bar"}
;TI";$ ruby collected_options.rb --xxx --yyy FOO --yyy BAR
;TI" {:xxx=>true, :yyy=>"BAR"}
;T;0o;
;[I"RNote in the last execution that the argument value for option --yyy ;TI"was overwritten.;T@
S; ;
i ; I"!Checking for Missing Options;T@
o;
;[I"