ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- PK]kOeof-i.rinu[U:RDoc::AnyMethod[iI"eof:ETI" ARGF#eof;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"OReturns true if the current file in +ARGF+ is at end of file, i.e. it has ;TI"Lno data to read. The stream must be opened for reading or an +IOError+ ;TI"will be raised.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"!$ echo "eof" | ruby argf.rb ;TI" ;TI")ARGF.eof? #=> false ;TI"3.times { ARGF.readchar } ;TI")ARGF.eof? #=> false ;TI"(ARGF.readchar #=> "\n" ;TI"'ARGF.eof? #=> true;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I" true or false ARGF.eof -> true or false;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]Cread_nonblock-i.rinu[U:RDoc::AnyMethod[iI"read_nonblock:ETI"ARGF#read_nonblock;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"LReads at most _maxlen_ bytes from the ARGF stream in non-blocking mode.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"iARGF.read_nonblock(maxlen) -> string ARGF.read_nonblock(maxlen, outbuf) -> outbuf ;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK]/   readchar-i.rinu[U:RDoc::AnyMethod[iI" readchar:ETI"ARGF#readchar;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"OReads the next character from +ARGF+ and returns it as a +String+. Raises ;TI"Kan +EOFError+ after the last character of the last file has been read.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [ I"$ echo "foo" > file ;TI"$ ruby argf.rb file ;TI" ;TI"ARGF.readchar #=> "f" ;TI"ARGF.readchar #=> "o" ;TI"ARGF.readchar #=> "o" ;TI"ARGF.readchar #=> "\n" ;TI"6ARGF.readchar #=> end of file reached (EOFError);T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"%ARGF.readchar -> String or nil ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]e11lineno%3d-i.rinu[U:RDoc::AnyMethod[iI" lineno=:ETI"ARGF#lineno=;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"FSets the line number of +ARGF+ as a whole to the given +Integer+.;To:RDoc::Markup::BlankLineo; ; [I"M+ARGF+ sets the line number automatically as you read data, so normally ;TI"Oyou will not need to set it explicitly. To access the current line number ;TI"use +ARGF.lineno+.;T@o; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [ I"ARGF.lineno #=> 0 ;TI"-ARGF.readline #=> "This is line 1\n" ;TI"ARGF.lineno #=> 1 ;TI"ARGF.lineno = 0 #=> 0 ;TI"ARGF.lineno #=> 0;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"'ARGF.lineno = integer -> integer ;T0[I" (p1);T@FI" ARGF;TcRDoc::NormalClass00PK]`٪CC readline-i.rinu[U:RDoc::AnyMethod[iI" readline:ETI"ARGF#readline;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I";Returns the next line from the current file in +ARGF+.;To:RDoc::Markup::BlankLineo; ; [I"NBy default lines are assumed to be separated by +$/+; to use a different ;TI"Ncharacter as a separator, supply it as a +String+ for the _sep_ argument.;T@o; ; [I"OThe optional _limit_ argument specifies how many characters of each line ;TI"7to return. By default all characters are returned.;T@o; ; [I"4An +EOFError+ is raised at the end of the file.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"qARGF.readline(sep=$/) -> string ARGF.readline(limit) -> string ARGF.readline(sep, limit) -> string ;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK]iuueach_byte-i.rinu[U:RDoc::AnyMethod[iI"each_byte:ETI"ARGF#each_byte;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Verbatim; [I"5Iterates over each byte of each file in +ARGV+. ;TI";A byte is returned as a +Fixnum+ in the range 0..255. ;TI" ;TI"OThis method allows you to treat the files supplied on the command line as ;TI"Ma single file consisting of the concatenation of each named file. After ;TI"Nthe last byte of the first file has been returned, the first byte of the ;TI"Hsecond file is returned. The +ARGF.filename+ method can be used to ;TI"1determine the filename of the current byte. ;TI" ;TI">If no block is given, an enumerator is returned instead. ;T: @format0o:RDoc::Markup::Paragraph; [I"For example:;To:RDoc::Markup::BlankLineo; ; [I".ARGF.bytes.to_a #=> [35, 32, ... 95, 10];T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.bytes {|byte| block } -> ARGF ARGF.bytes -> an_enumerator ARGF.each_byte {|byte| block } -> ARGF ARGF.each_byte -> an_enumerator ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]`PPbinmode%3f-i.rinu[U:RDoc::AnyMethod[iI" binmode?:ETI"ARGF#binmode?;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Verbatim; [I"OReturns true if +ARGF+ is being read in binary mode; false otherwise. (To ;TI",enable binary mode use +ARGF.binmode+. ;T: @format0o:RDoc::Markup::Paragraph; [I"For example:;To:RDoc::Markup::BlankLineo; ; [I"ARGF.binmode? #=> false ;TI"ARGF.binmode ;TI"ARGF.binmode? #=> true;T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"%ARGF.binmode? -> true or false ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]'E inspect-i.rinu[U:RDoc::AnyMethod[iI" inspect:ETI"ARGF#inspect;TF: publico:RDoc::Markup::Document: @parts[: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below000[I"();T@ FI" ARGF;TcRDoc::NormalClass0[@FI" to_s;TPK]\}ZZ print-i.rinu[U:RDoc::AnyMethod[iI" print:ETI"ARGF#print;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"DWrites the given object(s) to ios. The stream must be ;TI"Iopened for writing. If the output field separator ($,) ;TI"Gis not nil, it will be inserted between each object. ;TI"7If the output record separator ($\\) ;TI"Gis not nil, it will be appended to the output. If no ;TI"Farguments are given, prints $_. Objects that aren't ;TI"Jstrings will be converted by calling their to_s method. ;TI"LWith no argument, prints the contents of the variable $_. ;TI"Returns nil.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"3$stdout.print("This is ", 100, " percent.\n") ;T: @format0o; ; [I"produces:;T@o; ; [I"This is 100 percent.;T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"Cios.print() -> nil ios.print(obj, ...) -> nil ;T0[I" (*args);T@ FI" ARGF;TcRDoc::NormalClass00PK]r to_a-i.rinu[U:RDoc::AnyMethod[iI" to_a:ETI"ARGF#to_a;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"NReads +ARGF+'s current file in its entirety, returning an +Array+ of its ;TI"Mlines, one line per element. Lines are assumed to be separated by _sep_.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"lines = ARGF.readlines ;TI"5lines[0] #=> "This is line one\n";T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"aARGF.to_a(sep=$/) -> array ARGF.to_a(limit) -> array ARGF.to_a(sep, limit) -> array;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK]2oinplace_mode-i.rinu[U:RDoc::AnyMethod[iI"inplace_mode:ETI"ARGF#inplace_mode;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"NReturns the file extension appended to the names of modified files under ;TI"Linplace-edit mode. This value can be set using +ARGF.inplace_mode=+ or ;TI"0passing the +-i+ switch to the Ruby binary.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I""ARGF.inplace_mode -> String ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]ZYninplace_mode%3d-i.rinu[U:RDoc::AnyMethod[iI"inplace_mode=:ETI"ARGF#inplace_mode=;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Verbatim; [I"OSets the filename extension for inplace editing mode to the given String. ;TI"IEach file being edited has this value appended to its filename. The ;TI"1modified file is saved under this new name. ;TI" ;TI"For example: ;TI" ;TI"! $ ruby argf.rb file.txt ;TI" ;TI"$ ARGF.inplace_mode = '.bak' ;TI" ARGF.lines do |line| ;TI"' print line.sub("foo","bar") ;TI" end ;T: @format0o:RDoc::Markup::Paragraph; [I"MEach line of _file.txt_ has the first occurrence of "foo" replaced with ;TI"?"bar", then the new line is written out to _file.txt.bak_.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"&ARGF.inplace_mode = ext -> ARGF ;T0[I" (p1);T@FI" ARGF;TcRDoc::NormalClass00PK] Ointernal_encoding-i.rinu[U:RDoc::AnyMethod[iI"internal_encoding:ETI"ARGF#internal_encoding;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"FReturns the internal encoding for strings read from +ARGF+ as an ;TI"+Encoding+ object.;To:RDoc::Markup::BlankLineo; ; [ I"PIf +ARGF.set_encoding+ has been called with two encoding names, the second ;TI"Ois returned. Otherwise, if +Encoding.default_external+ has been set, that ;TI"Ivalue is returned. Failing that, if a default external encoding was ;TI"Kspecified on the command-line, that value is used. If the encoding is ;TI"unknown, nil is returned.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"*ARGF.internal_encoding -> encoding ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]p2 readbyte-i.rinu[U:RDoc::AnyMethod[iI" readbyte:ETI"ARGF#readbyte;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"NReads the next 8-bit byte from ARGF and returns it as a +Fixnum+. Raises ;TI"Fan +EOFError+ after the last byte of the last file has been read.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [ I"$ echo "foo" > file ;TI"$ ruby argf.rb file ;TI" ;TI"ARGF.readbyte #=> 102 ;TI"ARGF.readbyte #=> 111 ;TI"ARGF.readbyte #=> 111 ;TI"ARGF.readbyte #=> 10 ;TI"6ARGF.readbyte #=> end of file reached (EOFError);T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.readbyte -> Fixnum ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]><< puts-i.rinu[U:RDoc::AnyMethod[iI" puts:ETI"ARGF#puts;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [ I"6Writes the given objects to ios as with ;TI"CIO#print. Writes a record separator (typically a ;TI"Inewline) after any that do not already end with a newline sequence. ;TI"JIf called with an array argument, writes each element on a new line. ;TI"DIf called without arguments, outputs a single record separator.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"-$stdout.puts("this", "is", "a", "test") ;T: @format0o; ; [I"produces:;T@o; ; [ I" this ;TI"is ;TI"a ;TI" test;T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I""ios.puts(obj, ...) -> nil ;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK] = eof%3f-i.rinu[U:RDoc::AnyMethod[iI" eof?:ETI"ARGF#eof?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"OReturns true if the current file in +ARGF+ is at end of file, i.e. it has ;TI"Lno data to read. The stream must be opened for reading or an +IOError+ ;TI"will be raised.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"!$ echo "eof" | ruby argf.rb ;TI" ;TI")ARGF.eof? #=> false ;TI"3.times { ARGF.readchar } ;TI")ARGF.eof? #=> false ;TI"(ARGF.readchar #=> "\n" ;TI"'ARGF.eof? #=> true;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I" ARGF.eof? -> true or false;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]1ct to_i-i.rinu[U:RDoc::AnyMethod[iI" to_i:ETI"ARGF#to_i;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EReturns an integer representing the numeric file descriptor for ;TI"Othe current file. Raises an +ArgumentError+ if there isn't a current file.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"ARGF.fileno #=> 3;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.to_i -> fixnum;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK] D>>codepoints-i.rinu[U:RDoc::AnyMethod[iI"codepoints:ETI"ARGF#codepoints;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"@This is a deprecated alias for each_codepoint.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below000[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]ث; file-i.rinu[U:RDoc::AnyMethod[iI" file:ETI"ARGF#file;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"LReturns the current file as an +IO+ or +File+ object. #> is ;TI"-returned when the current file is STDIN.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [ I"$ echo "foo" > foo ;TI"$ echo "bar" > bar ;TI" ;TI"$ ruby argf.rb foo bar ;TI" ;TI"$ARGF.file #=> # ;TI"!ARGF.read(5) #=> "foo\nb" ;TI"#ARGF.file #=> #;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"%ARGF.file -> IO or File object ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]]** argv-i.rinu[U:RDoc::AnyMethod[iI" argv:ETI"ARGF#argv;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"KReturns the +ARGV+ array, which contains the arguments passed to your ;TI"script, one per element.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [I"!$ ruby argf.rb -v glark.txt ;TI" ;TI"(ARGF.argv #=> ["-v", "glark.txt"];T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.argv -> ARGV ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]'~\ putc-i.rinu[U:RDoc::AnyMethod[iI" putc:ETI"ARGF#putc;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [ I"NIf obj is Numeric, write the character whose code is ;TI"Nthe least-significant byte of obj, otherwise write the first byte ;TI"Lof the string representation of obj to ios. Note: This ;TI"Omethod is not safe for use with multi-byte characters as it will truncate ;TI" them.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"$stdout.putc "A" ;TI"$stdout.putc 65 ;T: @format0o; ; [I"produces:;T@o; ; [I"AA;T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ios.putc(obj) -> obj ;T0[I" (p1);T@FI" ARGF;TcRDoc::NormalClass00PK]b` tell-i.rinu[U:RDoc::AnyMethod[iI" tell:ETI"ARGF#tell;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"IReturns the current offset (in bytes) of the current file in +ARGF+.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"ARGF.pos #=> 0 ;TI"*ARGF.gets #=> "This is line one\n" ;TI"ARGF.pos #=> 17;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.tell -> Integer;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]c getbyte-i.rinu[U:RDoc::AnyMethod[iI" getbyte:ETI"ARGF#getbyte;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"OGets the next 8-bit byte (0..255) from +ARGF+. Returns +nil+ if called at ;TI"the end of the stream.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [ I"$ echo "foo" > file ;TI"$ ruby argf.rb file ;TI" ;TI"ARGF.getbyte #=> 102 ;TI"ARGF.getbyte #=> 111 ;TI"ARGF.getbyte #=> 111 ;TI"ARGF.getbyte #=> 10 ;TI"ARGF.getbyte #=> nil;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"$ARGF.getbyte -> Fixnum or nil ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]n close-i.rinu[U:RDoc::AnyMethod[iI" close:ETI"ARGF#close;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Verbatim; [I"LCloses the current file and skips to the next in the stream. Trying to ;TI"Iclose a file that has already been closed causes an +IOError+ to be ;TI" raised. ;T: @format0o:RDoc::Markup::Paragraph; [I"For example:;To:RDoc::Markup::BlankLineo; ; [ I"$ ruby argf.rb foo bar ;TI" ;TI"ARGF.filename #=> "foo" ;TI"ARGF.close ;TI"ARGF.filename #=> "bar" ;TI"ARGF.close ;TI"/ARGF.close #=> closed stream (IOError);T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.close -> ARGF ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]Dd²each_char-i.rinu[U:RDoc::AnyMethod[iI"each_char:ETI"ARGF#each_char;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"9Iterates over each character of each file in +ARGF+.;To:RDoc::Markup::BlankLineo; ; [ I"OThis method allows you to treat the files supplied on the command line as ;TI"Ma single file consisting of the concatenation of each named file. After ;TI"Gthe last character of the first file has been returned, the first ;TI"Ncharacter of the second file is returned. The +ARGF.filename+ method can ;TI"Nbe used to determine the name of the file in which the current character ;TI" appears.;T@o; ; [I"=If no block is given, an enumerator is returned instead.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"`ARGF.each_char {|char| block } -> ARGF ARGF.each_char -> an_enumerator ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]F printf-i.rinu[U:RDoc::AnyMethod[iI" printf:ETI"ARGF#printf;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EFormats and writes to ios, converting parameters under ;TI"Ccontrol of the format string. See Kernel#sprintf ;TI"for details.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"5ios.printf(format_string [, obj, ...]) -> nil ;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK] U filename-i.rinu[U:RDoc::AnyMethod[iI" filename:ETI"ARGF#filename;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"LReturns the current filename. "-" is returned when the current file is ;TI" STDIN.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [I"$ echo "foo" > foo ;TI"$ echo "bar" > bar ;TI"$ echo "glark" > glark ;TI" ;TI""$ ruby argf.rb foo bar glark ;TI" ;TI"ARGF.filename #=> "foo" ;TI"!ARGF.read(5) #=> "foo\nb" ;TI"ARGF.filename #=> "bar" ;TI"ARGF.skip ;TI"ARGF.filename #=> "glark";T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.filename -> String;T0[I"();T@ FI" ARGF;TcRDoc::NormalClass00PK]*Gpos-i.rinu[U:RDoc::AnyMethod[iI"pos:ETI" ARGF#pos;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"IReturns the current offset (in bytes) of the current file in +ARGF+.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"ARGF.pos #=> 0 ;TI"*ARGF.gets #=> "This is line one\n" ;TI"ARGF.pos #=> 17;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.pos -> Integer;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK],,external_encoding-i.rinu[U:RDoc::AnyMethod[iI"external_encoding:ETI"ARGF#external_encoding;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Verbatim; [ I"OReturns the external encoding for files read from +ARGF+ as an +Encoding+ ;TI"Nobject. The external encoding is the encoding of the text as stored in a ;TI"Nfile. Contrast with +ARGF.internal_encoding+, which is the encoding used ;TI")to represent this text within Ruby. ;TI" ;TI";To set the external encoding use +ARGF.set_encoding+. ;T: @format0o:RDoc::Markup::Paragraph; [I"For example:;To:RDoc::Markup::BlankLineo; ; [I"3ARGF.external_encoding #=> #;T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"*ARGF.external_encoding -> encoding ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]WQ@@ to_s-i.rinu[U:RDoc::AnyMethod[iI" to_s:ETI"ARGF#to_s;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"Returns "ARGF".;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.to_s -> String ;T0[[I" inspect;To;; [; @; 0I"();T@FI" ARGF;TcRDoc::NormalClass00PK] : pos%3d-i.rinu[U:RDoc::AnyMethod[iI" pos=:ETI"ARGF#pos=;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"DSeeks to the position given by _position_ (in bytes) in +ARGF+.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [I"ARGF.pos = 17 ;TI")ARGF.gets #=> "This is line two\n";T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"%ARGF.pos = position -> Integer ;T0[I" (p1);T@FI" ARGF;TcRDoc::NormalClass00PK]&v_AA write-i.rinu[U:RDoc::AnyMethod[iI" write:ETI"ARGF#write;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"%Writes _string_ if inplace mode.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"%ARGF.write(string) -> integer ;T0[I" (p1);T@FI" ARGF;TcRDoc::NormalClass00PK] ڳeach_codepoint-i.rinu[U:RDoc::AnyMethod[iI"each_codepoint:ETI"ARGF#each_codepoint;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"9Iterates over each codepoint of each file in +ARGF+.;To:RDoc::Markup::BlankLineo; ; [ I"OThis method allows you to treat the files supplied on the command line as ;TI"Ma single file consisting of the concatenation of each named file. After ;TI"Gthe last codepoint of the first file has been returned, the first ;TI"Ncodepoint of the second file is returned. The +ARGF.filename+ method can ;TI"Nbe used to determine the name of the file in which the current codepoint ;TI" appears.;T@o; ; [I"=If no block is given, an enumerator is returned instead.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"oARGF.each_codepoint {|codepoint| block } -> ARGF ARGF.each_codepoint -> an_enumerator ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]@mkGG skip-i.rinu[U:RDoc::AnyMethod[iI" skip:ETI"ARGF#skip;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Verbatim; [I"NSets the current file to the next file in ARGV. If there aren't any more ;TI"files it has no effect. ;T: @format0o:RDoc::Markup::Paragraph; [I"For example:;To:RDoc::Markup::BlankLineo; ; [ I"$ ruby argf.rb foo bar ;TI"ARGF.filename #=> "foo" ;TI"ARGF.skip ;TI"ARGF.filename #=> "bar";T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.skip -> ARGF ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]L path-i.rinu[U:RDoc::AnyMethod[iI" path:ETI"ARGF#path;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"LReturns the current filename. "-" is returned when the current file is ;TI" STDIN.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [I"$ echo "foo" > foo ;TI"$ echo "bar" > bar ;TI"$ echo "glark" > glark ;TI" ;TI""$ ruby argf.rb foo bar glark ;TI" ;TI"ARGF.filename #=> "foo" ;TI"!ARGF.read(5) #=> "foo\nb" ;TI"ARGF.filename #=> "bar" ;TI"ARGF.skip ;TI"ARGF.filename #=> "glark";T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.path -> String;T0[I"();T@ FI" ARGF;TcRDoc::NormalClass00PK]FQQ to_io-i.rinu[U:RDoc::AnyMethod[iI" to_io:ETI"ARGF#to_io;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"JReturns an +IO+ object representing the current file. This will be a ;TI"E+File+ object unless the current file is a stream such as STDIN.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [I")ARGF.to_io #=> # ;TI"$ARGF.to_io #=> #>;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.to_io -> IO ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]{N seek-i.rinu[U:RDoc::AnyMethod[iI" seek:ETI"ARGF#seek;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"OSeeks to offset _amount_ (an +Integer+) in the +ARGF+ stream according to ;TI">the value of _whence_. See +IO#seek+ for further details.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"3ARGF.seek(amount, whence=IO::SEEK_SET) -> 0 ;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK]P6 fileno-i.rinu[U:RDoc::AnyMethod[iI" fileno:ETI"ARGF#fileno;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EReturns an integer representing the numeric file descriptor for ;TI"Othe current file. Raises an +ArgumentError+ if there isn't a current file.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"ARGF.fileno #=> 3;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.fileno -> fixnum;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]zOaa read-i.rinu[U:RDoc::AnyMethod[iI" read:ETI"ARGF#read;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Verbatim; [I"IReads _length_ bytes from ARGF. The files named on the command line ;TI"Kare concatenated and treated as a single file by this method, so when ;TI"Ocalled without arguments the contents of this pseudo file are returned in ;TI"their entirety. ;TI" ;TI"I_length_ must be a non-negative integer or nil. If it is a positive ;TI"Jinteger, +read+ tries to read at most _length_ bytes. It returns nil ;TI"Iif an EOF was encountered before anything could be read. Fewer than ;TI"N_length_ bytes may be returned if an EOF is encountered during the read. ;TI" ;TI"IIf _length_ is omitted or is _nil_, it reads until EOF. A String is ;TI"Breturned even if EOF is encountered before any data is read. ;TI" ;TI"+If _length_ is zero, it returns _""_. ;TI" ;TI"OIf the optional _outbuf_ argument is present, it must reference a String, ;TI""which will receive the data. ;TI"QThe outbuf will contain only the received data after the method call ;TI"/even if it is not empty at the beginning. ;T: @format0o:RDoc::Markup::Paragraph; [I"For example:;To:RDoc::Markup::BlankLineo; ; [I"# $ echo "small" > small.txt ;TI"# $ echo "large" > large.txt ;TI") $ ./glark.rb small.txt large.txt ;TI" ;TI"* ARGF.read #=> "small\nlarge" ;TI"* ARGF.read(200) #=> "small\nlarge" ;TI" ARGF.read(2) #=> "sm" ;TI" ARGF.read(0) #=> "" ;TI" ;TI"PNote that this method behaves like fread() function in C. If you need the ;TI"Dbehavior like read(2) system call, consider +ARGF.readpartial+.;T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"AARGF.read([length [, outbuf]]) -> string, outbuf, or nil ;T0[I"(p1 = v1, p2 = v2);T@1FI" ARGF;TcRDoc::NormalClass00PK]B gets-i.rinu[U:RDoc::AnyMethod[iI" gets:ETI"ARGF#gets;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I";Returns the next line from the current file in +ARGF+.;To:RDoc::Markup::BlankLineo; ; [I"NBy default lines are assumed to be separated by +$/+; to use a different ;TI"Ncharacter as a separator, supply it as a +String+ for the _sep_ argument.;T@o; ; [I"NThe optional _limit_ argument specifies how many characters of each line ;TI"7to return. By default all characters are returned.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"zARGF.gets(sep=$/) -> string or nil ARGF.gets(limit) -> string or nil ARGF.gets(sep, limit) -> string or nil ;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK]Νa// bytes-i.rinu[U:RDoc::AnyMethod[iI" bytes:ETI"ARGF#bytes;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I";This is a deprecated alias for each_byte.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below000[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]ɒU binmode-i.rinu[U:RDoc::AnyMethod[iI" binmode:ETI"ARGF#binmode;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"NPuts +ARGF+ into binary mode. Once a stream is in binary mode, it cannot ;TI"Hbe reset to non-binary mode. This option has the following effects:;To:RDoc::Markup::BlankLineo:RDoc::Markup::List: @type: BULLET: @items[o:RDoc::Markup::ListItem: @label0; [o; ; [I"$Newline conversion is disabled.;To;;0; [o; ; [I"%Encoding conversion is disabled.;To;;0; [o; ; [I"&Content is treated as ASCII-8BIT.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.binmode -> ARGF ;T0[I"();T@!FI" ARGF;TcRDoc::NormalClass00PK]@ closed%3f-i.rinu[U:RDoc::AnyMethod[iI" closed?:ETI"ARGF#closed?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"PReturns _true_ if the current file has been closed; _false_ otherwise. Use ;TI"5+ARGF.close+ to actually close the current file.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"$ARGF.closed? -> true or false ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]ذMM rewind-i.rinu[U:RDoc::AnyMethod[iI" rewind:ETI"ARGF#rewind;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EPositions the current file to the beginning of input, resetting ;TI"+ARGF.lineno+ to zero.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I".ARGF.readline #=> "This is line one\n" ;TI"ARGF.rewind #=> 0 ;TI"ARGF.lineno #=> 0 ;TI"-ARGF.readline #=> "This is line one\n";T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.rewind -> 0 ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]!Dreadlines-i.rinu[U:RDoc::AnyMethod[iI"readlines:ETI"ARGF#readlines;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"NReads +ARGF+'s current file in its entirety, returning an +Array+ of its ;TI"Mlines, one line per element. Lines are assumed to be separated by _sep_.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"lines = ARGF.readlines ;TI"5lines[0] #=> "This is line one\n";T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"pARGF.readlines(sep=$/) -> array ARGF.readlines(limit) -> array ARGF.readlines(sep, limit) -> array;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK]R{// chars-i.rinu[U:RDoc::AnyMethod[iI" chars:ETI"ARGF#chars;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I";This is a deprecated alias for each_char.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below000[I"();T@FI" ARGF;TcRDoc::NormalClass00PK] cdesc-ARGF.rinu[U:RDoc::NormalClass[iI" ARGF:ET@I" Object;To:RDoc::Markup::Document: @parts[o;;[o:RDoc::Markup::Paragraph;[I"P+ARGF+ is a stream designed for use in scripts that process files given as ;TI"3command-line arguments or passed in via STDIN.;To:RDoc::Markup::BlankLineo; ;[I"MThe arguments passed to your script are stored in the +ARGV+ Array, one ;TI"Iargument per element. +ARGF+ assumes that any arguments that aren't ;TI":filenames have been removed from +ARGV+. For example:;T@o:RDoc::Markup::Verbatim;[ I"*$ ruby argf.rb --verbose file1 file2 ;TI" ;TI"/ARGV #=> ["--verbose", "file1", "file2"] ;TI")option = ARGV.shift #=> "--verbose" ;TI""ARGV #=> ["file1", "file2"] ;T: @format0o; ;[I"PYou can now use +ARGF+ to work with a concatenation of each of these named ;TI"Jfiles. For instance, +ARGF.read+ will return the contents of _file1_ ;TI")followed by the contents of _file2_.;T@o; ;[I"LAfter a file in +ARGV+ has been read +ARGF+ removes it from the Array. ;TI"?Thus, after all files have been read +ARGV+ will be empty.;T@o; ;[ I"OYou can manipulate +ARGV+ yourself to control what +ARGF+ operates on. If ;TI"Qyou remove a file from +ARGV+, it is ignored by +ARGF+; if you add files to ;TI"M+ARGV+, they are treated as if they were named on the command line. For ;TI" example:;T@o; ;[ I"ARGV.replace ["file1"] ;TI"@ARGF.readlines # Returns the contents of file1 as an Array ;TI"ARGV #=> [] ;TI"%ARGV.replace ["file2", "file3"] ;TI">ARGF.read # Returns the contents of file2 and file3 ;T; 0o; ;[I"MIf +ARGV+ is empty, +ARGF+ acts as if it contained STDIN, i.e. the data ;TI"'piped to your script. For example:;T@o; ;[I",$ echo "glark" | ruby -e 'p ARGF.read' ;TI""glark\n";T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0; 0;0[[[[I"Enumerable;To;;[; @<;0I" io.c;T[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[;[;[I" argv;T@D[I" binmode;T@D[I" binmode?;T@D[I" bytes;T@D[I" chars;T@D[I" close;T@D[I" closed?;T@D[I"codepoints;T@D[I" each;T@D[I"each_byte;T@D[I"each_char;T@D[I"each_codepoint;T@D[I"each_line;T@D[I"eof;T@D[I" eof?;T@D[I"external_encoding;T@D[I" file;T@D[I" filename;T@D[I" fileno;T@D[I" getbyte;T@D[I" getc;T@D[I" gets;T@D[I"inplace_mode;T@D[I"inplace_mode=;T@D[I" inspect;T@D[I"internal_encoding;T@D[I" lineno;T@D[I" lineno=;T@D[I" lines;T@D[I" path;T@D[I"pos;T@D[I" pos=;T@D[I" print;T@D[I" printf;T@D[I" putc;T@D[I" puts;T@D[I" read;T@D[I"read_nonblock;T@D[I" readbyte;T@D[I" readchar;T@D[I" readline;T@D[I"readlines;T@D[I"readpartial;T@D[I" rewind;T@D[I" seek;T@D[I"set_encoding;T@D[I" skip;T@D[I" tell;T@D[I" to_a;T@D[I" to_i;T@D[I" to_io;T@D[I" to_s;T@D[I"to_write_io;T@D[I" write;T@D[;[[;[[[U:RDoc::Context::Section[i0o;;[; 0;0[@<@ io ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK]76 each-i.rinu[U:RDoc::AnyMethod[iI" each:ETI"ARGF#each;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [ I"NReturns an enumerator which iterates over each line (separated by _sep_, ;TI"Jwhich defaults to your platform's newline character) of each file in ;TI"N+ARGV+. If a block is supplied, each line in turn will be yielded to the ;TI"1block, otherwise an enumerator is returned. ;TI"HThe optional _limit_ argument is a +Fixnum+ specifying the maximum ;TI"Mlength of each line; longer lines will be split according to this limit.;To:RDoc::Markup::BlankLineo; ; [ I"OThis method allows you to treat the files supplied on the command line as ;TI"Ma single file consisting of the concatenation of each named file. After ;TI"Nthe last line of the first file has been returned, the first line of the ;TI"Psecond file is returned. The +ARGF.filename+ and +ARGF.lineno+ methods can ;TI"Mbe used to determine the filename and line number, respectively, of the ;TI"current line.;T@o; ; [I"MFor example, the following code prints out each line of each named file ;TI"Jprefixed with its line number, displaying the filename once per file:;T@o:RDoc::Markup::Verbatim; [ I"ARGF.lines do |line| ;TI". puts ARGF.filename if ARGF.lineno == 1 ;TI"& puts "#{ARGF.lineno}: #{line}" ;TI"end;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"UARGF.each(sep=$/) {|line| block } -> ARGF ARGF.each(sep=$/,limit) {|line| block } -> ARGF ARGF.each(...) -> an_enumerator ARGF.each_line(sep=$/) {|line| block } -> ARGF ARGF.each_line(sep=$/,limit) {|line| block } -> ARGF ARGF.each_line(...) -> an_enumerator;T0[I" (*args);T@&FI" ARGF;TcRDoc::NormalClass00PK]c  getc-i.rinu[U:RDoc::AnyMethod[iI" getc:ETI"ARGF#getc;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"PReads the next character from +ARGF+ and returns it as a +String+. Returns ;TI"$+nil+ at the end of the stream.;To:RDoc::Markup::BlankLineo; ; [I"P+ARGF+ treats the files named on the command line as a single file created ;TI"Pby concatenating their contents. After returning the last character of the ;TI"Nfirst file, it returns the first character of the second file, and so on.;T@o; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [I"$ echo "foo" > file ;TI"$ ruby argf.rb file ;TI" ;TI"ARGF.getc #=> "f" ;TI"ARGF.getc #=> "o" ;TI"ARGF.getc #=> "o" ;TI"ARGF.getc #=> "\n" ;TI"ARGF.getc #=> nil ;TI"ARGF.getc #=> nil;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"!ARGF.getc -> String or nil ;T0[I"();T@#FI" ARGF;TcRDoc::NormalClass00PK]UpGG lineno-i.rinu[U:RDoc::AnyMethod[iI" lineno:ETI"ARGF#lineno;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"DReturns the current line number of ARGF as a whole. This value ;TI"-can be set manually with +ARGF.lineno=+.;To:RDoc::Markup::BlankLineo; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [I"ARGF.lineno #=> 0 ;TI"*ARGF.readline #=> "This is line 1\n" ;TI"ARGF.lineno #=> 1;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.lineno -> integer ;T0[I"();T@FI" ARGF;TcRDoc::NormalClass00PK] d44 lines-i.rinu[U:RDoc::AnyMethod[iI" lines:ETI"ARGF#lines;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I";This is a deprecated alias for each_line.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below000[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK]set_encoding-i.rinu[U:RDoc::AnyMethod[iI"set_encoding:ETI"ARGF#set_encoding;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"MIf single argument is specified, strings read from ARGF are tagged with ;TI"the encoding specified.;To:RDoc::Markup::BlankLineo; ; [ I"OIf two encoding names separated by a colon are given, e.g. "ascii:utf-8", ;TI"Nthe read string is converted from the first encoding (external encoding) ;TI"Mto the second encoding (internal encoding), then tagged with the second ;TI"encoding.;T@o; ; [I"OIf two arguments are specified, they must be encoding objects or encoding ;TI"Inames. Again, the first specifies the external encoding; the second ;TI"%specifies the internal encoding.;T@o; ; [I"KIf the external encoding and the internal encoding are specified, the ;TI"Poptional +Hash+ argument can be used to adjust the conversion process. The ;TI"Nstructure of this hash is explained in the +String#encode+ documentation.;T@o; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [ I"IARGF.set_encoding('ascii') # Tag the input as US-ASCII text ;TI"FARGF.set_encoding(Encoding::UTF_8) # Tag the input as UTF-8 text ;TI"LARGF.set_encoding('utf-8','ascii') # Transcode the input from US-ASCII ;TI"3 # to UTF-8.;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.set_encoding(ext_enc) -> ARGF ARGF.set_encoding("ext_enc:int_enc") -> ARGF ARGF.set_encoding(ext_enc, int_enc) -> ARGF ARGF.set_encoding("ext_enc:int_enc", opt) -> ARGF ARGF.set_encoding(ext_enc, int_enc, opt) -> ARGF ;T0[I" (*args);T@)FI" ARGF;TcRDoc::NormalClass00PK]Ӏ|readpartial-i.rinu[U:RDoc::AnyMethod[iI"readpartial:ETI"ARGF#readpartial;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"7Reads at most _maxlen_ bytes from the ARGF stream.;To:RDoc::Markup::BlankLineo; ; [ I"3If the optional _outbuf_ argument is present, ;TI">it must reference a String, which will receive the data. ;TI"QThe outbuf will contain only the received data after the method call ;TI".even if it is not empty at the beginning.;T@o; ; [ I"EOFError on end of ARGF stream. ;TI"=Since ARGF stream is a concatenation of multiple files, ;TI",internally EOF is occur for each file. ;TI"MARGF.readpartial returns empty strings for EOFs except the last one and ;TI"3raises EOFError for the last one.;T: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"eARGF.readpartial(maxlen) -> string ARGF.readpartial(maxlen, outbuf) -> outbuf ;T0[I" (*args);T@FI" ARGF;TcRDoc::NormalClass00PK]v\}}each_line-i.rinu[U:RDoc::AnyMethod[iI"each_line:ETI"ARGF#each_line;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [ I"NReturns an enumerator which iterates over each line (separated by _sep_, ;TI"Jwhich defaults to your platform's newline character) of each file in ;TI"N+ARGV+. If a block is supplied, each line in turn will be yielded to the ;TI"1block, otherwise an enumerator is returned. ;TI"HThe optional _limit_ argument is a +Fixnum+ specifying the maximum ;TI"Mlength of each line; longer lines will be split according to this limit.;To:RDoc::Markup::BlankLineo; ; [ I"OThis method allows you to treat the files supplied on the command line as ;TI"Ma single file consisting of the concatenation of each named file. After ;TI"Nthe last line of the first file has been returned, the first line of the ;TI"Psecond file is returned. The +ARGF.filename+ and +ARGF.lineno+ methods can ;TI"Mbe used to determine the filename and line number, respectively, of the ;TI"current line.;T@o; ; [I"MFor example, the following code prints out each line of each named file ;TI"Jprefixed with its line number, displaying the filename once per file:;T@o:RDoc::Markup::Verbatim; [ I"ARGF.lines do |line| ;TI". puts ARGF.filename if ARGF.lineno == 1 ;TI"& puts "#{ARGF.lineno}: #{line}" ;TI"end;T: @format0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"ARGF.each_line(sep=$/) {|line| block } -> ARGF ARGF.each_line(sep=$/,limit) {|line| block } -> ARGF ARGF.each_line(...) -> an_enumerator;T0[I" (*args);T@&FI" ARGF;TcRDoc::NormalClass00PK]kOeof-i.rinu[PK]CPread_nonblock-i.rinu[PK]/   Qreadchar-i.rinu[PK]e11lineno%3d-i.rinu[PK]`٪CC  readline-i.rinu[PK]iuueach_byte-i.rinu[PK]`PP;binmode%3f-i.rinu[PK]'E inspect-i.rinu[PK]\}ZZ print-i.rinu[PK]r to_a-i.rinu[PK]2oGinplace_mode-i.rinu[PK]ZYn{!inplace_mode%3d-i.rinu[PK] O>%internal_encoding-i.rinu[PK]p2 (readbyte-i.rinu[PK]><< +puts-i.rinu[PK] = F/eof%3f-i.rinu[PK]1ct 2to_i-i.rinu[PK] D>>4codepoints-i.rinu[PK]ث; 96file-i.rinu[PK]]** 59argv-i.rinu[PK]'~\ ;putc-i.rinu[PK]b` >tell-i.rinu[PK]c Agetbyte-i.rinu[PK]n Cclose-i.rinu[PK]Dd²Feach_char-i.rinu[PK]F Jprintf-i.rinu[PK] U Lfilename-i.rinu[PK]*GPpos-i.rinu[PK],,3Rexternal_encoding-i.rinu[PK]WQ@@ Uto_s-i.rinu[PK] : Wpos%3d-i.rinu[PK]&v_AA WYwrite-i.rinu[PK] ڳZeach_codepoint-i.rinu[PK]@mkGG ^skip-i.rinu[PK]L Hapath-i.rinu[PK]FQQ edto_io-i.rinu[PK]{N fseek-i.rinu[PK]P6 hfileno-i.rinu[PK]zOaa &kread-i.rinu[PK]B rgets-i.rinu[PK]Νa// ubytes-i.rinu[PK]ɒU ewbinmode-i.rinu[PK]@ azclosed%3f-i.rinu[PK]ذMM C|rewind-i.rinu[PK]!D~readlines-i.rinu[PK]R{// chars-i.rinu[PK] cdesc-ARGF.rinu[PK]ttLto_write_io-i.rinu[PK]76 each-i.rinu[PK]c  Xgetc-i.rinu[PK]UpGG Slineno-i.rinu[PK] d44 ՞lines-i.rinu[PK]Cset_encoding-i.rinu[PK]Ӏ|=readpartial-i.rinu[PK]v\}}seach_line-i.rinu[PK77].