1#@!#!123s

��JFIF�� 1#@!#!123s
: / opt / alt / ruby34 / share / ri / system / optparse /
Filename : page-argument_converters_rdoc.ri
back
U:RDoc::TopLevel[	i�I"&optparse/argument_converters.rdoc:ETcRDoc::Parser::Simpleo:RDoc::Markup::Document:@parts[�S:RDoc::Markup::Heading:
leveli:	textI"Argument Converters;To:RDoc::Markup::BlankLine�o:RDoc::Markup::Paragraph;[I"@An option can specify that its argument is to be converted ;TI"?from the default +String+ to an instance of another class.;T@
S;	;
i;I"
Contents;T@
o:RDoc::Markup::List:
@type:BULLET:@items[o:RDoc::Markup::ListItem:@label0;[o;
;[I"H{Built-In Argument Converters}[#label-Built-In+Argument+Converters];To;;;;[o;;0;[o;
;[I"{Date}[#label-Date];To;;0;[o;
;[I" {DateTime}[#label-DateTime];To;;0;[o;
;[I"{Time}[#label-Time];To;;0;[o;
;[I"{URI}[#label-URI];To;;0;[o;
;[I"${Shellwords}[#label-Shellwords];To;;0;[o;
;[I"{Integer}[#label-Integer];To;;0;[o;
;[I"{Float}[#label-Float];To;;0;[o;
;[I"{Numeric}[#label-Numeric];To;;0;[o;
;[I",{DecimalInteger}[#label-DecimalInteger];To;;0;[o;
;[I"({OctalInteger}[#label-OctalInteger];To;;0;[o;
;[I",{DecimalNumeric}[#label-DecimalNumeric];To;;0;[o;
;[I""{TrueClass}[#label-TrueClass];To;;0;[o;
;[I"${FalseClass}[#label-FalseClass];To;;0;[o;
;[I"{Object}[#label-Object];To;;0;[o;
;[I"{String}[#label-String];To;;0;[o;
;[I"{Array}[#label-Array];To;;0;[o;
;[I"{Regexp}[#label-Regexp];To;;0;[o;
;[I"D{Custom Argument Converters}[#label-Custom+Argument+Converters];T@
S;	;
i;I"!Built-In Argument Converters;T@
o;
;[I"B+OptionParser+ has a number of built-in argument converters, ;TI""which are demonstrated below.;T@
S;	;
i	;I"+Date+;T@
o;
;[I"File +date.rb+ ;TI"Mdefines an option whose argument is to be converted to a +Date+ object. ;TI"4The argument is converted by method Date#parse.;T@
o:RDoc::Markup::Verbatim;[I"require 'optparse/date'
;TI"parser = OptionParser.new
;TI"/parser.on('--date=DATE', Date) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T:@format0o;
;[I"Executions:;T@
o;;[I"&$ ruby date.rb --date 2001-02-03
;TI"A[#<Date: 2001-02-03 ((2451944j,0s,0n),+0s,2299161j)>, Date]
;TI"$$ ruby date.rb --date 20010203
;TI"A[#<Date: 2001-02-03 ((2451944j,0s,0n),+0s,2299161j)>, Date]
;TI"*$ ruby date.rb --date "3rd Feb 2001"
;TI"A[#<Date: 2001-02-03 ((2451944j,0s,0n),+0s,2299161j)>, Date]
;T;0S;	;
i	;I"+DateTime+;T@
o;
;[I"File +datetime.rb+ ;TI"Qdefines an option whose argument is to be converted to a +DateTime+ object. ;TI"8The argument is converted by method DateTime#parse.;T@
o;;[I"require 'optparse/date'
;TI"parser = OptionParser.new
;TI";parser.on('--datetime=DATETIME', DateTime) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I"=$ ruby datetime.rb --datetime 2001-02-03T04:05:06+07:00
;TI"`[#<DateTime: 2001-02-03T04:05:06+07:00 ((2451943j,75906s,0n),+25200s,2299161j)>, DateTime]
;TI"8$ ruby datetime.rb --datetime 20010203T040506+0700
;TI"`[#<DateTime: 2001-02-03T04:05:06+07:00 ((2451943j,75906s,0n),+25200s,2299161j)>, DateTime]
;TI">$ ruby datetime.rb --datetime "3rd Feb 2001 04:05:06 PM"
;TI"\[#<DateTime: 2001-02-03T16:05:06+00:00 ((2451944j,57906s,0n),+0s,2299161j)>, DateTime]
;T;0S;	;
i	;I"+Time+;T@
o;
;[I"File +time.rb+ ;TI"Mdefines an option whose argument is to be converted to a +Time+ object. ;TI"EThe argument is converted by method Time#httpdate or Time#parse.;T@
o;;[I"require 'optparse/time'
;TI"parser = OptionParser.new
;TI"/parser.on('--time=TIME', Time) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[	I";$ ruby time.rb --time "Thu, 06 Oct 2011 02:26:12 GMT"
;TI"%[2011-10-06 02:26:12 UTC, Time]
;TI"&$ ruby time.rb --time 2010-10-31
;TI"'[2010-10-31 00:00:00 -0500, Time]
;T;0S;	;
i	;I"
+URI+;T@
o;
;[I"File +uri.rb+ ;TI"Ldefines an option whose argument is to be converted to a +URI+ object. ;TI"3The argument is converted by method URI#parse.;T@
o;;[I"require 'optparse/uri'
;TI"parser = OptionParser.new
;TI",parser.on('--uri=URI', URI) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I",$ ruby uri.rb --uri https://github.com
;TI"4[#<URI::HTTPS https://github.com>, URI::HTTPS]
;TI"+$ ruby uri.rb --uri http://github.com
;TI"1[#<URI::HTTP http://github.com>, URI::HTTP]
;TI"&$ ruby uri.rb --uri file://~/var
;TI",[#<URI::File file://~/var>, URI::File]
;T;0S;	;
i	;I"+Shellwords+;T@
o;
;[I"File +shellwords.rb+ ;TI"Xdefines an option whose argument is to be converted to an +Array+ object by method ;TI"Shellwords#shellwords.;T@
o;;[I"#require 'optparse/shellwords'
;TI"parser = OptionParser.new
;TI"Aparser.on('--shellwords=SHELLWORDS', Shellwords) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[	I"@$ ruby shellwords.rb --shellwords "ruby my_prog.rb | less"
;TI"2[["ruby", "my_prog.rb", "|", "less"], Array]
;TI">$ ruby shellwords.rb --shellwords "here are 'two words'"
;TI"+[["here", "are", "two words"], Array]
;T;0S;	;
i	;I"+Integer+;T@
o;
;[I"File +integer.rb+ ;TI"Qdefines an option whose argument is to be converted to an +Integer+ object. ;TI"8The argument is converted by method Kernel#Integer.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"8parser.on('--integer=INTEGER', Integer) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I"%$ ruby integer.rb --integer 100
;TI"[100, Integer]
;TI"&$ ruby integer.rb --integer -100
;TI"[-100, Integer]
;TI"&$ ruby integer.rb --integer 0100
;TI"[64, Integer]
;TI"'$ ruby integer.rb --integer 0x100
;TI"[256, Integer]
;TI"'$ ruby integer.rb --integer 0b100
;TI"[4, Integer]
;T;0S;	;
i	;I"+Float+;T@
o;
;[I"File +float.rb+ ;TI"Ndefines an option whose argument is to be converted to a +Float+ object. ;TI"6The argument is converted by method Kernel#Float.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"2parser.on('--float=FLOAT', Float) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[
I"$ ruby float.rb --float 1
;TI"[1.0, Float]
;TI"%$ ruby float.rb --float 3.14159
;TI"[3.14159, Float]
;TI"%$ ruby float.rb --float 1.234E2
;TI"[123.4, Float]
;TI"&$ ruby float.rb --float 1.234E-2
;TI"[0.01234, Float]
;T;0S;	;
i	;I"+Numeric+;T@
o;
;[
I"File +numeric.rb+ ;TI"Hdefines an option whose argument is to be converted to an instance ;TI"+of +Rational+, +Float+, or +Integer+. ;TI":The argument is converted by method Kernel#Rational, ;TI"%Kernel#Float, or Kernel#Integer.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"8parser.on('--numeric=NUMERIC', Numeric) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I"%$ ruby numeric.rb --numeric 1/3
;TI"[(1/3), Rational]
;TI"*$ ruby numeric.rb --numeric 3.333E-1
;TI"[0.3333, Float]
;TI"#$ ruby numeric.rb --numeric 3
;TI"[3, Integer]
;T;0S;	;
i	;I"+DecimalInteger+;T@
o;
;[I"File +decimal_integer.rb+ ;TI"Qdefines an option whose argument is to be converted to an +Integer+ object. ;TI"8The argument is converted by method Kernel#Integer.;T@
o;;[I"require 'optparse'
;TI"'include OptionParser::Acceptables
;TI"parser = OptionParser.new
;TI"Oparser.on('--decimal_integer=DECIMAL_INTEGER', DecimalInteger) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"@The argument may not be in a binary or hexadecimal format; ;TI"5a leading zero is ignored (not parsed as octal).;T@
o;
;[I"Executions:;T@
o;;[
I"5$ ruby decimal_integer.rb --decimal_integer 100
;TI"[100, Integer]
;TI"6$ ruby decimal_integer.rb --decimal_integer -100
;TI"[-100, Integer]
;TI"6$ ruby decimal_integer.rb --decimal_integer 0100
;TI"[100, Integer]
;TI"7$ ruby decimal_integer.rb --decimal_integer -0100
;TI"[-100, Integer]
;T;0S;	;
i	;I"+OctalInteger+;T@
o;
;[I"File +octal_integer.rb+ ;TI"Qdefines an option whose argument is to be converted to an +Integer+ object. ;TI"8The argument is converted by method Kernel#Integer.;T@
o;;[I"require 'optparse'
;TI"'include OptionParser::Acceptables
;TI"parser = OptionParser.new
;TI"Iparser.on('--octal_integer=OCTAL_INTEGER', OctalInteger) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"@The argument may not be in a binary or hexadecimal format; ;TI"Hit is parsed as octal, regardless of whether it has a leading zero.;T@
o;
;[I"Executions:;T@
o;;[I"1$ ruby octal_integer.rb --octal_integer 100
;TI"[64, Integer]
;TI"2$ ruby octal_integer.rb --octal_integer -100
;TI"[-64, Integer]
;TI"2$ ruby octal_integer.rb --octal_integer 0100
;TI"[64, Integer]
;T;0S;	;
i	;I"+DecimalNumeric+;T@
o;
;[I"File +decimal_numeric.rb+ ;TI"Qdefines an option whose argument is to be converted to an +Integer+ object. ;TI"7The argument is converted by method Kernel#Integer;T@
o;;[I"require 'optparse'
;TI"'include OptionParser::Acceptables
;TI"parser = OptionParser.new
;TI"Oparser.on('--decimal_numeric=DECIMAL_NUMERIC', DecimalNumeric) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"@The argument may not be in a binary or hexadecimal format; ;TI">a leading zero causes the argument to be parsed as octal.;T@
o;
;[I"Executions:;T@
o;;[I"5$ ruby decimal_numeric.rb --decimal_numeric 100
;TI"[100, Integer]
;TI"6$ ruby decimal_numeric.rb --decimal_numeric -100
;TI"[-100, Integer]
;TI"6$ ruby decimal_numeric.rb --decimal_numeric 0100
;TI"[64, Integer]
;T;0S;	;
i	;I"+TrueClass+;T@
o;
;[I"File +true_class.rb+ ;TI"Odefines an option whose argument is to be converted to +true+ or +false+. ;TI"5The argument is evaluated by method Object#nil?.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"@parser.on('--true_class=TRUE_CLASS', TrueClass) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"BThe argument may be any of those shown in the examples below.;T@
o;
;[I"Executions:;T@
o;;[I",$ ruby true_class.rb --true_class true
;TI"[true, TrueClass]
;TI"+$ ruby true_class.rb --true_class yes
;TI"[true, TrueClass]
;TI")$ ruby true_class.rb --true_class +
;TI"[true, TrueClass]
;TI"-$ ruby true_class.rb --true_class false
;TI"[false, FalseClass]
;TI"*$ ruby true_class.rb --true_class no
;TI"[false, FalseClass]
;TI")$ ruby true_class.rb --true_class -
;TI"[false, FalseClass]
;TI"+$ ruby true_class.rb --true_class nil
;TI"[false, FalseClass]
;T;0S;	;
i	;I"+FalseClass+;T@
o;
;[I"File +false_class.rb+ ;TI"Odefines an option whose argument is to be converted to +true+ or +false+. ;TI"5The argument is evaluated by method Object#nil?.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"Cparser.on('--false_class=FALSE_CLASS', FalseClass) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"BThe argument may be any of those shown in the examples below.;T@
o;
;[I"Executions:;T@
o;;[I"/$ ruby false_class.rb --false_class false
;TI"[false, FalseClass]
;TI",$ ruby false_class.rb --false_class no
;TI"[false, FalseClass]
;TI"+$ ruby false_class.rb --false_class -
;TI"[false, FalseClass]
;TI"-$ ruby false_class.rb --false_class nil
;TI"[false, FalseClass]
;TI".$ ruby false_class.rb --false_class true
;TI"[true, TrueClass]
;TI"-$ ruby false_class.rb --false_class yes
;TI"[true, TrueClass]
;TI"+$ ruby false_class.rb --false_class +
;TI"[true, TrueClass]
;T;0S;	;
i	;I"
+Object+;T@
o;
;[I"File +object.rb+ ;TI"Kdefines an option whose argument is not to be converted from +String+.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"5parser.on('--object=OBJECT', Object) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[	I"#$ ruby object.rb --object foo
;TI"["foo", String]
;TI"#$ ruby object.rb --object nil
;TI"["nil", String]
;T;0S;	;
i	;I"
+String+;T@
o;
;[I"File +string.rb+ ;TI"Kdefines an option whose argument is not to be converted from +String+.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"5parser.on('--string=STRING', String) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[	I"#$ ruby string.rb --string foo
;TI"["foo", String]
;TI"#$ ruby string.rb --string nil
;TI"["nil", String]
;T;0S;	;
i	;I"+Array+;T@
o;
;[I"File +array.rb+ ;TI"Gdefines an option whose argument is to be converted from +String+ ;TI"Ato an array of strings, based on comma-separated substrings.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"2parser.on('--array=ARRAY', Array) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I" $ ruby array.rb --array ""
;TI"[[], Array]
;TI")$ ruby array.rb --array foo,bar,baz
;TI"$[["foo", "bar", "baz"], Array]
;TI"-$ ruby array.rb --array "foo, bar, baz"
;TI"&[["foo", " bar", " baz"], Array]
;T;0S;	;
i	;I"
+Regexp+;T@
o;
;[I"File +regexp.rb+ ;TI"Ndefines an option whose argument is to be converted to a +Regexp+ object.;T@
o;;[I"require 'optparse'
;TI"parser = OptionParser.new
;TI"5parser.on('--regexp=REGEXP', Regexp) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[I"#$ ruby regexp.rb --regexp foo
;T;0S;	;
i;I"Custom Argument Converters;T@
o;
;[I"0You can create custom argument converters. ;TI"ATo create a custom converter, call OptionParser#accept with:;T@
o;;;;[o;;0;[o;
;[I",An identifier, which may be any object.;To;;0;[o;
;[I"AAn optional match pattern, which defaults to <tt>/.*/m</tt>.;To;;0;[o;
;[I"GA block that accepts the argument and returns the converted value.;T@
o;
;[I"AThis custom converter accepts any argument and converts it, ;TI"(if possible, to a +Complex+ object.;T@
o;;[I"require 'optparse/date'
;TI"parser = OptionParser.new
;TI"'parser.accept(Complex) do |value|
;TI"  value.to_c
;TI"	end
;TI"8parser.on('--complex COMPLEX', Complex) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[
I",$ ruby custom_converter.rb --complex 0
;TI"[(0+0i), Complex]
;TI",$ ruby custom_converter.rb --complex 1
;TI"[(1+0i), Complex]
;TI"/$ ruby custom_converter.rb --complex 1+2i
;TI"[(1+2i), Complex]
;TI"3$ ruby custom_converter.rb --complex 0.3-0.5i
;TI"[(0.3-0.5i), Complex]
;T;0o;
;[I"7This custom converter accepts any 1-word argument ;TI"%and capitalizes it, if possible.;T@
o;;[I"require 'optparse/date'
;TI"parser = OptionParser.new
;TI"2parser.accept(:capitalize, /\w*/) do |value|
;TI"  value.capitalize
;TI"	end
;TI";parser.on('--capitalize XXX', :capitalize) do |value|
;TI"  p [value, value.class]
;TI"	end
;TI"parser.parse!
;T;0o;
;[I"Executions:;T@
o;;[	I"0$ ruby match_converter.rb --capitalize foo
;TI"["Foo", String]
;TI"6$ ruby match_converter.rb --capitalize "foo bar"
;TI"mmatch_converter.rb:9:in `<main>': invalid argument: --capitalize foo bar (OptionParser::InvalidArgument);T;0:
@file@:0@omit_headings_from_table_of_contents_below0