ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- instance_variable_defined%3f-i.ri000064400000001646152410544230012762 0ustar00U:RDoc::AnyMethod[iI"instance_variable_defined?:ETI"&Object#instance_variable_defined?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"AReturns true if the given instance variable is ;TI"defined in obj. ;TI"/String arguments are converted to symbols.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"class Fred ;TI" def initialize(p1, p2) ;TI" @a, @b = p1, p2 ;TI" end ;TI" end ;TI" fred = Fred.new('cat', 99) ;TI"6fred.instance_variable_defined?(:@a) #=> true ;TI"6fred.instance_variable_defined?("@b") #=> true ;TI"6fred.instance_variable_defined?("@c") #=> false;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"{obj.instance_variable_defined?(symbol) -> true or false obj.instance_variable_defined?(string) -> true or false ;T0[I" (p1);T@FI" Object;TcRDoc::NormalClass00private_methods-i.ri000064400000001001152410544230010513 0ustar00U:RDoc::AnyMethod[iI"private_methods:ETI"Object#private_methods;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"FReturns the list of private methods accessible to obj. If ;FI"Othe all parameter is set to false, only those methods ;FI"$in the receiver will be listed.;F: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I".obj.private_methods(all=true) -> array ;F0[I" (*args);T@FI" Object;TcRDoc::NormalClass00default_src_encoding-i.ri000064400000000522152410544230011466 0ustar00U:RDoc::AnyMethod[iI"default_src_encoding:EFI" Object#default_src_encoding;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I")DO NOT WRITE ANY MAGIC COMMENT HERE.;T: @fileI"lib/irb/src_encoding.rb;T:0@omit_headings_from_table_of_contents_below000[I"();T@FI" Object;TcRDoc::NormalClass00public_send-i.ri000064400000001336152410544230007620 0ustar00U:RDoc::AnyMethod[iI"public_send:ETI"Object#public_send;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"?Invokes the method identified by _symbol_, passing it any ;TI"@arguments specified. Unlike send, public_send calls public ;TI"methods only. ;TI"HWhen the method is identified by a string, the string is converted ;TI"to a symbol.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I":1.public_send(:puts, "hello") # causes NoMethodError;T: @format0: @fileI"vm_eval.c;T:0@omit_headings_from_table_of_contents_below0I"]obj.public_send(symbol [, args...]) -> obj obj.public_send(string [, args...]) -> obj ;T0[I" (*args);T@FI" Object;TcRDoc::NormalClass00%3d%7e-i.ri000064400000000664152410544230006210 0ustar00U:RDoc::AnyMethod[iI"=~:ETI"Object#=~;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"8Pattern Match---Overridden by descendants (notably ;TI"HRegexp and String) to provide meaningful ;TI"pattern-match semantics.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj =~ other -> nil ;T0[I" (p1);T@FI" Object;TcRDoc::NormalClass00kind_of%3f-i.ri000064400000001732152410544230007240 0ustar00U:RDoc::AnyMethod[iI" kind_of?:ETI"Object#kind_of?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"?Returns true if class is the class of ;TI"Bobj, or if class is one of the superclasses of ;TI"2obj or modules included in obj.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"module M; end ;TI" class A ;TI" include M ;TI" end ;TI"class B < A; end ;TI"class C < B; end ;TI" ;TI"b = B.new ;TI"!b.is_a? A #=> true ;TI"!b.is_a? B #=> true ;TI""b.is_a? C #=> false ;TI"!b.is_a? M #=> true ;TI" ;TI"!b.kind_of? A #=> true ;TI"!b.kind_of? B #=> true ;TI""b.kind_of? C #=> false ;TI" b.kind_of? M #=> true;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I",obj.kind_of?(class) -> true or false;T0[I" (p1);T@$FI" Object;TcRDoc::NormalClass00respond_to_missing%3f-i.ri000064400000001360152410544230011531 0ustar00U:RDoc::AnyMethod[iI"respond_to_missing?:ETI"Object#respond_to_missing?;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"DO NOT USE THIS DIRECTLY.;To:RDoc::Markup::BlankLineo; ; [I"HHook method to return whether the _obj_ can respond to _id_ method ;TI" or not.;T@o; ; [I"HWhen the method name parameter is given as a string, the string is ;TI"converted to a symbol.;T@o; ; [I"6See #respond_to?, and the example of BasicObject.;T: @fileI"vm_method.c;T:0@omit_headings_from_table_of_contents_below0I"|obj.respond_to_missing?(symbol, include_all) -> true or false obj.respond_to_missing?(string, include_all) -> true or false ;T0[I" (p1, p2);T@FI" Object;TcRDoc::NormalClass00psych_to_yaml-i.ri000064400000000721152410544230010200 0ustar00U:RDoc::AnyMethod[iI"psych_to_yaml:EFI"Object#psych_to_yaml;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"LConvert an object to YAML. See Psych.dump for more information on the ;TI"available +options+.;T: @fileI"$ext/psych/lib/psych/core_ext.rb;T:0@omit_headings_from_table_of_contents_below0I"to_yaml(options = {}) ;T0[[I" to_yaml;To;; [; @; 0I"(options = {});T@FI" Object;TcRDoc::NormalClass00inspect-i.ri000064400000002414152410544230006774 0ustar00U:RDoc::AnyMethod[iI" inspect:ETI"Object#inspect;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"PReturns a string containing a human-readable representation of obj. ;TI"EThe default inspect shows the object's class name, ;TI"Lan encoding of the object id, and a list of the instance variables and ;TI"9their values (by calling #inspect on each of them). ;TI"JUser defined classes should override this method to provide a better ;TI"Krepresentation of obj. When overriding this method, it should ;TI"Lreturn a string whose encoding is compatible with the default external ;TI"encoding.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"C[ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]" ;TI"FTime.new.inspect #=> "2008-03-08 19:43:39 +0900" ;TI" ;TI"class Foo ;TI" end ;TI">Foo.new.inspect #=> "#" ;TI" ;TI"class Bar ;TI" def initialize ;TI" @bar = 1 ;TI" end ;TI" end ;TI"DBar.new.inspect #=> "#";T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.inspect -> string ;T0[I"();T@%FI" Object;TcRDoc::NormalClass00respond_to%3f-i.ri000064400000001755152410544230010010 0ustar00U:RDoc::AnyMethod[iI"respond_to?:ETI"Object#respond_to?;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"HReturns +true+ if _obj_ responds to the given method. Private and ;TI"Gprotected methods are included in the search only if the optional ;TI"*second parameter evaluates to +true+.;To:RDoc::Markup::BlankLineo; ; [I"'If the method is not implemented, ;TI"Aas Process.fork on Windows, File.lchmod on GNU/Linux, etc., ;TI"false is returned.;T@o; ; [I"DIf the method is not defined, respond_to_missing? ;TI"1method is called and the result is returned.;T@o; ; [I"HWhen the method name parameter is given as a string, the string is ;TI"converted to a symbol.;T: @fileI"vm_method.c;T:0@omit_headings_from_table_of_contents_below0I"}obj.respond_to?(symbol, include_all=false) -> true or false obj.respond_to?(string, include_all=false) -> true or false ;T0[I"(p1, p2 = v2);T@FI" Object;TcRDoc::NormalClass00untrust-i.ri000064400000000515152410544230007053 0ustar00U:RDoc::AnyMethod[iI" untrust:ETI"Object#untrust;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"4Deprecated method that is equivalent to #taint.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.untrust -> obj ;T0[I"();T@FI" Object;TcRDoc::NormalClass00instance_variable_get-i.ri000064400000002046152410544230011640 0ustar00U:RDoc::AnyMethod[iI"instance_variable_get:ETI"!Object#instance_variable_get;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"EReturns the value of the given instance variable, or nil if the ;TI"Binstance variable is not set. The @ part of the ;TI";variable name should be included for regular instance ;TI"Avariables. Throws a NameError exception if the ;TI"@supplied symbol is not valid as an instance variable name. ;TI"/String arguments are converted to symbols.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"class Fred ;TI" def initialize(p1, p2) ;TI" @a, @b = p1, p2 ;TI" end ;TI" end ;TI" fred = Fred.new('cat', 99) ;TI"2fred.instance_variable_get(:@a) #=> "cat" ;TI".fred.instance_variable_get("@b") #=> 99;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"]obj.instance_variable_get(symbol) -> obj obj.instance_variable_get(string) -> obj ;T0[I" (p1);T@FI" Object;TcRDoc::NormalClass00CSV-i.ri000064400000001406152410544230005762 0ustar00U:RDoc::AnyMethod[iI"CSV:EFI"Object#CSV;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"$Passes +args+ to CSV::instance.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"CSV("CSV,data").read ;TI" #=> [["CSV", "data"]] ;T: @format0o; ; [I"PIf a block is given, the instance is passed the block and the return value ;TI"+becomes the return value of the block.;T@o; ; [ I"CSV("CSV,data") { |c| ;TI". c.read.any? { |a| a.include?("data") } ;TI"} #=> true ;TI" ;TI"CSV("CSV,data") { |c| ;TI"1 c.read.any? { |a| a.include?("zombies") } ;TI"} #=> false;T; 0: @fileI"lib/csv.rb;T:0@omit_headings_from_table_of_contents_below000[I"(*args, &block);T@ FI" Object;TcRDoc::NormalClass00enum_for-i.ri000064400000004044152410544230007142 0ustar00U:RDoc::AnyMethod[iI" enum_for:ETI"Object#enum_for;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"JCreates a new Enumerator which will enumerate by calling +method+ on ;TI""+obj+, passing +args+ if any.;To:RDoc::Markup::BlankLineo; ; [I"CIf a block is given, it will be used to calculate the size of ;TI"Ithe enumerator without the need to iterate it (see Enumerator#size).;T@S:RDoc::Markup::Heading: leveli: textI" Examples;T@o:RDoc::Markup::Verbatim; [I"str = "xyz" ;TI" ;TI"%enum = str.enum_for(:each_byte) ;TI"enum.each { |b| puts b } ;TI"# => 120 ;TI"# => 121 ;TI"# => 122 ;TI" ;TI";# protect an array from being modified by some_method ;TI"a = [1, 2, 3] ;TI"some_method(a.to_enum) ;T: @format0o; ; [I"=It is typical to call to_enum when defining methods for ;TI"6a generic Enumerable, in case no block is passed.;T@o; ; [I"HHere is such an example, with parameter passing and a sizing block:;T@o;; [I"module Enumerable ;TI"A # a generic method to repeat the values of any enumerable ;TI" def repeat(n) ;TI"; raise ArgumentError, "#{n} is negative!" if n < 0 ;TI" unless block_given? ;TI"I return to_enum(__method__, n) do # __method__ is :repeat here ;TI"< sz = size # Call size and multiply by n... ;TI"B sz * n if sz # but return nil if size itself is nil ;TI" end ;TI" end ;TI" each do |*val| ;TI"" n.times { yield *val } ;TI" end ;TI" end ;TI" end ;TI" ;TI".%i[hello world].repeat(2) { |w| puts w } ;TI"6 # => Prints 'hello', 'hello', 'world', 'world' ;TI"enum = (1..14).repeat(3) ;TI"> # => returns an Enumerator when called without a block ;TI"%enum.first(4) # => [1, 1, 1, 2] ;TI"enum.size # => 42;T;0: @fileI"enumerator.c;T:0@omit_headings_from_table_of_contents_below0I"zobj.enum_for(method = :each, *args) -> enum obj.enum_for(method = :each, *args){|*args| block} -> enum;T0[I" (*args);T@BFI" Object;TcRDoc::NormalClass00untaint-i.ri000064400000000624152410544230007012 0ustar00U:RDoc::AnyMethod[iI" untaint:ETI"Object#untaint;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I".Removes the tainted mark from the object.;To:RDoc::Markup::BlankLineo; ; [I"%See #taint for more information.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.untaint -> obj ;T0[I"();T@FI" Object;TcRDoc::NormalClass00Digest-i.ri000064400000001132152410544230006542 0ustar00U:RDoc::AnyMethod[iI" Digest:EFI"Object#Digest;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I")Returns a Digest subclass by +name+.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"require 'digest' ;TI" ;TI"Digest("MD5") ;TI"# => Digest::MD5 ;TI" ;TI"Digest("Foo") ;TI"J# => LoadError: library not found for class Digest::Foo -- digest/foo;T: @format0: @fileI"ext/digest/lib/digest.rb;T:0@omit_headings_from_table_of_contents_below0I"%Digest(name) -> digest_subclass ;T0[I" (name);T@FI" Object;TcRDoc::NormalClass00eql%3f-i.ri000064400000003366152410544230006415 0ustar00U:RDoc::AnyMethod[iI" eql?:ETI"Object#eql?;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [ I"LEquality --- At the Object level, == returns ;TI"Ftrue only if +obj+ and +other+ are the same object. ;TI"KTypically, this method is overridden in descendant classes to provide ;TI"class-specific meaning.;To:RDoc::Markup::BlankLineo; ; [ I"LUnlike ==, the equal? method should never be ;TI"Ioverridden by subclasses as it is used to determine object identity ;TI"M(that is, a.equal?(b) if and only if a is the ;TI"$same object as b):;T@o:RDoc::Markup::Verbatim; [ I"obj = "a" ;TI"other = obj.dup ;TI" ;TI" obj == other #=> true ;TI"!obj.equal? other #=> false ;TI" obj.equal? obj #=> true ;T: @format0o; ; [ I"IThe eql? method returns true if +obj+ and ;TI"O+other+ refer to the same hash key. This is used by Hash to test members ;TI"Pfor equality. For objects of class Object, eql? ;TI"Lis synonymous with ==. Subclasses normally continue this ;TI"Qtradition by aliasing eql? to their overridden == ;TI"Hmethod, but there are exceptions. Numeric types, for ;TI"Mexample, perform type conversion across ==, but not across ;TI"eql?, so:;T@o; ; [I"1 == 1.0 #=> true ;TI"1.eql? 1.0 #=> false;T; 0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"tobj == other -> true or false obj.equal?(other) -> true or false obj.eql?(other) -> true or false ;T0[I" (p1);T@.FI" Object;TcRDoc::NormalClass00xmp-i.ri000064400000001614152410544230006134 0ustar00U:RDoc::AnyMethod[iI"xmp:EFI"Object#xmp;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"cA convenience method that's only available when the you require the IRB::XMP standard library.;To:RDoc::Markup::BlankLineo; ; [I"ICreates a new XMP object, using the given expressions as the +exps+ ;TI"Sparameter, and optional binding as +bind+ or uses the top-level binding. Then ;TI"Bevaluates the given expressions using the +:XMP+ prompt mode.;T@o; ; [I"For example:;T@o:RDoc::Markup::Verbatim; [ I"require 'irb/xmp' ;TI"ctx = binding ;TI"xmp 'foo = "bar"', ctx ;TI"#=> foo = "bar" ;TI" #==>"bar" ;TI"ctx.eval 'foo' ;TI"#=> "bar" ;T: @format0o; ; [I"&See XMP.new for more information.;T: @fileI"lib/irb/xmp.rb;T:0@omit_headings_from_table_of_contents_below000[I"(exps, bind = nil);T@#FI" Object;TcRDoc::NormalClass00instance_variables-i.ri000064400000001314152410544230011161 0ustar00U:RDoc::AnyMethod[iI"instance_variables:ETI"Object#instance_variables;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"HReturns an array of instance variable names for the receiver. Note ;FI"Hthat simply defining an accessor does not create the corresponding ;FI"instance variable.;Fo:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"class Fred ;TI" attr_accessor :a1 ;TI" def initialize ;TI" @iv = 3 ;TI" end ;TI" end ;TI"-Fred.new.instance_variables #=> [:@iv];T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"(obj.instance_variables -> array ;F0[I"();T@FI" Object;TcRDoc::NormalClass00dclone-i.ri000064400000000573152410544230006577 0ustar00U:RDoc::AnyMethod[iI" dclone:EFI"Object#dclone;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"Bprovides a unified +clone+ operation, for REXML::XPathParser ;TI"(to use across multiple Object types;T: @fileI"lib/rexml/xpath_parser.rb;T:0@omit_headings_from_table_of_contents_below000[I"();T@FI" Object;TcRDoc::NormalClass00freeze-i.ri000064400000001455152410544230006613 0ustar00U:RDoc::AnyMethod[iI" freeze:ETI"Object#freeze;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [ I"5Prevents further modifications to obj. A ;TI"LRuntimeError will be raised if modification is attempted. ;TI";There is no way to unfreeze a frozen object. See also ;TI"!Object#frozen?.;To:RDoc::Markup::BlankLineo; ; [I"This method returns self.;T@o:RDoc::Markup::Verbatim; [I"a = [ "a", "b", "c" ] ;TI"a.freeze ;TI"a << "z" ;T: @format0o; ; [I"produces:;T@o; ; [I"Aprog.rb:3:in `<<': can't modify frozen array (RuntimeError) ;TI" from prog.rb:3;T; 0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.freeze -> obj ;T0[I"();T@!FI" Object;TcRDoc::NormalClass00display-i.ri000064400000001265152410544230006777 0ustar00U:RDoc::AnyMethod[iI" display:ETI"Object#display;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"DPrints obj on the given port (default $>). ;TI"Equivalent to:;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"def display(port=$>) ;TI" port.write self ;TI" end ;T: @format0o; ; [I"For example:;T@o; ; [ I"1.display ;TI""cat".display ;TI"[ 4, 5, 6 ].display ;TI" puts ;T; 0o; ; [I"produces:;T@o; ; [I" 1cat456;T; 0: @fileI" io.c;T:0@omit_headings_from_table_of_contents_below0I"$obj.display(port=$>) -> nil ;T0[I"(p1 = v1);T@$FI" Object;TcRDoc::NormalClass00to_enum-i.ri000064400000004042152410544230006774 0ustar00U:RDoc::AnyMethod[iI" to_enum:ETI"Object#to_enum;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"JCreates a new Enumerator which will enumerate by calling +method+ on ;TI""+obj+, passing +args+ if any.;To:RDoc::Markup::BlankLineo; ; [I"CIf a block is given, it will be used to calculate the size of ;TI"Ithe enumerator without the need to iterate it (see Enumerator#size).;T@S:RDoc::Markup::Heading: leveli: textI" Examples;T@o:RDoc::Markup::Verbatim; [I"str = "xyz" ;TI" ;TI"%enum = str.enum_for(:each_byte) ;TI"enum.each { |b| puts b } ;TI"# => 120 ;TI"# => 121 ;TI"# => 122 ;TI" ;TI";# protect an array from being modified by some_method ;TI"a = [1, 2, 3] ;TI"some_method(a.to_enum) ;T: @format0o; ; [I"=It is typical to call to_enum when defining methods for ;TI"6a generic Enumerable, in case no block is passed.;T@o; ; [I"HHere is such an example, with parameter passing and a sizing block:;T@o;; [I"module Enumerable ;TI"A # a generic method to repeat the values of any enumerable ;TI" def repeat(n) ;TI"; raise ArgumentError, "#{n} is negative!" if n < 0 ;TI" unless block_given? ;TI"I return to_enum(__method__, n) do # __method__ is :repeat here ;TI"< sz = size # Call size and multiply by n... ;TI"B sz * n if sz # but return nil if size itself is nil ;TI" end ;TI" end ;TI" each do |*val| ;TI"" n.times { yield *val } ;TI" end ;TI" end ;TI" end ;TI" ;TI".%i[hello world].repeat(2) { |w| puts w } ;TI"6 # => Prints 'hello', 'hello', 'world', 'world' ;TI"enum = (1..14).repeat(3) ;TI"> # => returns an Enumerator when called without a block ;TI"%enum.first(4) # => [1, 1, 1, 2] ;TI"enum.size # => 42;T;0: @fileI"enumerator.c;T:0@omit_headings_from_table_of_contents_below0I"zobj.to_enum(method = :each, *args) -> enum obj.to_enum(method = :each, *args) {|*args| block} -> enum;T0[I" (*args);T@BFI" Object;TcRDoc::NormalClass00yaml_tag-c.ri000064400000000374152410544230007121 0ustar00U:RDoc::AnyMethod[iI" yaml_tag:EFI"Object::yaml_tag;TT: publico:RDoc::Markup::Document: @parts[: @fileI"$ext/psych/lib/psych/core_ext.rb;T:0@omit_headings_from_table_of_contents_below000[I" (url);T@ FI" Object;TcRDoc::NormalClass00singleton_method-i.ri000064400000001446152410544230010675 0ustar00U:RDoc::AnyMethod[iI"singleton_method:ETI"Object#singleton_method;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"9Similar to _method_, searches singleton method only.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"class Demo ;TI" def initialize(n) ;TI" @iv = n ;TI" end ;TI" def hello() ;TI" "Hello, @iv = #{@iv}" ;TI" end ;TI" end ;TI" ;TI"k = Demo.new(99) ;TI"def k.hi ;TI" "Hi, @iv = #{@iv}" ;TI" end ;TI"!m = k.singleton_method(:hi) ;TI"!m.call #=> "Hi, @iv = 99" ;TI"1m = k.singleton_method(:hello) #=> NameError;T: @format0: @fileI" proc.c;T:0@omit_headings_from_table_of_contents_below0I",obj.singleton_method(sym) -> method ;T0[I" (p1);T@!FI" Object;TcRDoc::NormalClass00singleton_methods-i.ri000064400000002131152410544230011050 0ustar00U:RDoc::AnyMethod[iI"singleton_methods:ETI"Object#singleton_methods;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"HReturns an array of the names of singleton methods for obj. ;FI"IIf the optional all parameter is true, the list will include ;FI"0methods in modules included in obj. ;FI">Only public and protected singleton methods are returned.;Fo:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"module Other ;TI" def three() end ;TI" end ;TI" ;TI"class Single ;TI" def Single.four() end ;TI" end ;TI" ;TI"a = Single.new ;TI" ;TI"def a.one() ;TI" end ;TI" ;TI"class << a ;TI" include Other ;TI" def two() ;TI" end ;TI" end ;TI" ;TI"-Single.singleton_methods #=> [:four] ;TI"2a.singleton_methods(false) #=> [:two, :one] ;TI"9a.singleton_methods #=> [:two, :one, :three];T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"1obj.singleton_methods(all=true) -> array ;F0[I"(p1 = v1);T@*FI" Object;TcRDoc::NormalClass00dup-i.ri000064400000003205152410544230006116 0ustar00U:RDoc::AnyMethod[iI"dup:ETI"Object#dup;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"GProduces a shallow copy of obj---the instance variables of ;TI"@obj are copied, but not the objects they reference. ;TI"=dup copies the tainted state of obj.;To:RDoc::Markup::BlankLineo; ; [I"@This method may have class-specific behavior. If so, that ;TI"Hbehavior will be documented under the #+initialize_copy+ method of ;TI"the class.;T@S:RDoc::Markup::Heading: leveli: textI"on dup vs clone;T@o; ; [ I"LIn general, clone and dup may have different ;TI"Jsemantics in descendant classes. While clone is used to ;TI"Iduplicate an object, including its internal state, dup ;TI"Itypically uses the class of the descendant object to create the new ;TI"instance.;T@o; ; [I"RWhen using #dup, any modules that the object has been extended with will not ;TI"be copied.;T@o:RDoc::Markup::Verbatim; [I"class Klass ;TI" attr_accessor :str ;TI" end ;TI" ;TI"module Foo ;TI" def foo; 'foo'; end ;TI" end ;TI" ;TI",s1 = Klass.new #=> # ;TI",s1.extend(Foo) #=> # ;TI"s1.foo #=> "foo" ;TI" ;TI"+s2 = s1.clone #=> # ;TI"s2.foo #=> "foo" ;TI" ;TI")s3 = s1.dup #=> # ;TI"Ms3.foo #=> NoMethodError: undefined method `foo' for #;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.dup -> an_object ;T0[I"();T@6FI" Object;TcRDoc::NormalClass00timeout-i.ri000064400000001032152410544230007010 0ustar00U:RDoc::AnyMethod[iI" timeout:EFI"Object#timeout;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"Identical to:;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"%Timeout::timeout(n, e, &block). ;T: @format0o; ; [I"NThis method is deprecated and provided only for backwards compatibility. ;TI",You should use Timeout#timeout instead.;T: @fileI"lib/timeout.rb;T:0@omit_headings_from_table_of_contents_below000[I"(n, e = nil, &block);T@FI" Object;TcRDoc::NormalClass00frozen%3f-i.ri000064400000000765152410544230007137 0ustar00U:RDoc::AnyMethod[iI" frozen?:ETI"Object#frozen?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"-Returns the freeze status of obj.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"a = [ "a", "b", "c" ] ;TI"%a.freeze #=> ["a", "b", "c"] ;TI"a.frozen? #=> true;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"%obj.frozen? -> true or false ;T0[I"();T@FI" Object;TcRDoc::NormalClass00sysread-i.ri000064400000001221152410544230006774 0ustar00U:RDoc::AnyMethod[iI" sysread:EFI"Object#sysread;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"#cgi_runner.rb -- CGI launcher.;To:RDoc::Markup::BlankLineo; ; [ I">Author: IPR -- Internet Programming with Ruby -- writers ;TI":Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU ;TI"KCopyright (c) 2002 Internet Programming with Ruby writers. All rights ;TI"reserved.;T@o; ; [I"A$IPR: cgi_runner.rb,v 1.9 2002/09/25 11:33:15 gotoyuzo Exp $;T: @fileI"*lib/webrick/httpservlet/cgi_runner.rb;T:0@omit_headings_from_table_of_contents_below000[I"(io, size);T@FI" Object;TcRDoc::NormalClass00protected_methods-i.ri000064400000001011152410544230011033 0ustar00U:RDoc::AnyMethod[iI"protected_methods:ETI"Object#protected_methods;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"HReturns the list of protected methods accessible to obj. If ;FI"Othe all parameter is set to false, only those methods ;FI"$in the receiver will be listed.;F: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"0obj.protected_methods(all=true) -> array ;F0[I" (*args);T@FI" Object;TcRDoc::NormalClass00extend-i.ri000064400000001457152410544230006624 0ustar00U:RDoc::AnyMethod[iI" extend:ETI"Object#extend;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"DAdds to _obj_ the instance methods from each module given as a ;TI"parameter.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"module Mod ;TI" def hello ;TI" "Hello from Mod.\n" ;TI" end ;TI" end ;TI" ;TI"class Klass ;TI" def hello ;TI" "Hello from Klass.\n" ;TI" end ;TI" end ;TI" ;TI"k = Klass.new ;TI"/k.hello #=> "Hello from Klass.\n" ;TI"-k.extend(Mod) #=> # ;TI",k.hello #=> "Hello from Mod.\n";T: @format0: @fileI" eval.c;T:0@omit_headings_from_table_of_contents_below0I"'obj.extend(module, ...) -> obj ;T0[I" (*args);T@"FI" Object;TcRDoc::NormalClass00to_s-i.ri000064400000001044152410544230006271 0ustar00U:RDoc::AnyMethod[iI" to_s:ETI"Object#to_s;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I";Returns a string representing obj. The default ;TI"Hto_s prints the object's class and an encoding of the ;TI"Dobject id. As a special case, the top-level object that is the ;TI"Ainitial execution context of Ruby programs returns ``main''.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.to_s -> string ;T0[I"();T@FI" Object;TcRDoc::NormalClass00is_a%3f-i.ri000064400000001724152410544230006543 0ustar00U:RDoc::AnyMethod[iI" is_a?:ETI"Object#is_a?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"?Returns true if class is the class of ;TI"Bobj, or if class is one of the superclasses of ;TI"2obj or modules included in obj.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"module M; end ;TI" class A ;TI" include M ;TI" end ;TI"class B < A; end ;TI"class C < B; end ;TI" ;TI"b = B.new ;TI"!b.is_a? A #=> true ;TI"!b.is_a? B #=> true ;TI""b.is_a? C #=> false ;TI"!b.is_a? M #=> true ;TI" ;TI"!b.kind_of? A #=> true ;TI"!b.kind_of? B #=> true ;TI""b.kind_of? C #=> false ;TI" b.kind_of? M #=> true;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I",obj.is_a?(class) -> true or false;T0[I" (p1);T@$FI" Object;TcRDoc::NormalClass00trust-i.ri000064400000000514152410544230006507 0ustar00U:RDoc::AnyMethod[iI" trust:ETI"Object#trust;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"6Deprecated method that is equivalent to #untaint.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.trust -> obj ;T0[I"();T@FI" Object;TcRDoc::NormalClass00send-i.ri000064400000001725152410544230006264 0ustar00U:RDoc::AnyMethod[iI" send:ETI"Object#send;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"?Invokes the method identified by _symbol_, passing it any ;TI"Harguments specified. You can use __send__ if the name ;TI"6+send+ clashes with an existing method in _obj_. ;TI"HWhen the method is identified by a string, the string is converted ;TI"to a symbol.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"class Klass ;TI" def hello(*args) ;TI"# "Hello " + args.join(' ') ;TI" end ;TI" end ;TI"k = Klass.new ;TI"Dk.send :hello, "gentle", "readers" #=> "Hello gentle readers";T: @format0: @fileI"vm_eval.c;T:0@omit_headings_from_table_of_contents_below0I"¨foo.send(symbol [, args...]) -> obj foo.__send__(symbol [, args...]) -> obj foo.send(string [, args...]) -> obj foo.__send__(string [, args...]) -> obj ;T0[I" (*args);T@FI" Object;TcRDoc::NormalClass00public_methods-i.ri000064400000000775152410544230010340 0ustar00U:RDoc::AnyMethod[iI"public_methods:ETI"Object#public_methods;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"EReturns the list of public methods accessible to obj. If ;FI"Othe all parameter is set to false, only those methods ;FI"$in the receiver will be listed.;F: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"-obj.public_methods(all=true) -> array ;F0[I" (*args);T@FI" Object;TcRDoc::NormalClass00remove_instance_variable-i.ri000064400000001433152410544230012355 0ustar00U:RDoc::AnyMethod[iI"remove_instance_variable:ETI"$Object#remove_instance_variable;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"IRemoves the named instance variable from obj, returning that ;FI"variable's value.;Fo:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"class Dummy ;TI" attr_reader :var ;TI" def initialize ;TI" @var = 99 ;TI" end ;TI" def remove ;TI") remove_instance_variable(:@var) ;TI" end ;TI" end ;TI"d = Dummy.new ;TI"d.var #=> 99 ;TI"d.remove #=> 99 ;TI"d.var #=> nil;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"4obj.remove_instance_variable(symbol) -> obj ;F0[I" (p1);T@FI" Object;TcRDoc::NormalClass00untrusted%3f-i.ri000064400000000546152410544230007666 0ustar00U:RDoc::AnyMethod[iI"untrusted?:ETI"Object#untrusted?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"7Deprecated method that is equivalent to #tainted?.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"(obj.untrusted? -> true or false ;T0[I"();T@FI" Object;TcRDoc::NormalClass00cdesc-Object.ri000064400000020652152410544230007372 0ustar00U:RDoc::NormalClass[iI" Object:ET@I"BasicObject;To:RDoc::Markup::Document: @parts[ o;;[: @fileI" class.c;T:0@omit_headings_from_table_of_contents_below0o;;[; I"$ext/psych/lib/psych/core_ext.rb;T; 0o;;[; I"&ext/psych/lib/psych/deprecated.rb;T; 0o;;[; I"lib/irb/ext/use-loader.rb;T; 0o;;[; I"lib/rexml/xpath_parser.rb;T; 0o;;[ o:RDoc::Markup::Paragraph;[I"KObject is the default root of all Ruby objects. Object inherits from ;TI"NBasicObject which allows creating alternate object hierarchies. Methods ;TI"Ion Object are available to all classes unless explicitly overridden.;To:RDoc::Markup::BlankLineo; ;[I"MObject mixes in the Kernel module, making the built-in kernel functions ;TI"Oglobally accessible. Although the instance methods of Object are defined ;TI"Lby the Kernel module, we have chosen to document them here for clarity.;T@!o; ;[I"MWhen referencing constants in classes inheriting from Object you do not ;TI"Mneed to use the full namespace. For example, referencing +File+ inside ;TI"4+YourClass+ will find the top-level File class.;T@!o; ;[I"QIn the descriptions of Object's methods, the parameter symbol refers ;TI"Gto a symbol, which is either a quoted string or a Symbol (such as ;TI":name).;T; I" object.c;T; 0; 0; 0[[U:RDoc::Constant[iI"SCRIPT_LINES__;TI"Object::SCRIPT_LINES__;T00o;;[o; ;[I"NWhen a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded ;TI"Kafter the assignment will be added as an Array of lines with the file ;TI"name as the key.;T; I"ext/ripper/ripper.c;T; 0@?@cRDoc::NormalClass0U; [iI"ENV;TI"Object::ENV;T00o;;[o; ;[I";ENV is a Hash-like accessor for environment variables.;T@!o; ;[I"*See ENV (the class) for more details.;T; I" hash.c;T; 0@M@@@0U; [iI" STDIN;TI"Object::STDIN;T00o;;[o; ;[I"Holds the original stdin;T@!; I" io.c;T; 0@W@@@0U; [iI" STDOUT;TI"Object::STDOUT;T00o;;[o; ;[I"Holds the original stdout;T@!; @W; 0@W@@@0U; [iI" STDERR;TI"Object::STDERR;T00o;;[o; ;[I"Holds the original stderr;T@!; @W; 0@W@@@0U; [iI" ARGF;TI"Object::ARGF;T00o;;[o; ;[I"KARGF is a stream designed for use in scripts that process files given ;TI"6as command-line arguments or passed in via STDIN.;T@!o; ;[I"+See ARGF (the class) for more details.;T; @W; 0@W@@@0U; [iI"ParseError;FI"Object::ParseError;T0I"Racc::ParseError;To;;[; I"lib/racc/parser.rb;T; 0@~@@@0U; [iI"Synchronizer_m;FI"Object::Synchronizer_m;T0I" Sync_m;Fo;;[o; ;[I"__END__:;T@!o;;[ I"$ cat t.rb ;TI"puts DATA.gets ;TI" __END__ ;TI"hello world! ;TI" ;TI"$ ruby t.rb ;TI"hello world!;T;0; I" ruby.c;T; 0@â@@@0U; [iI" ARGV;TI"Object::ARGV;T00o;;[o; ;[I"HARGV contains the command line arguments used to run ruby with the ;TI"7first value containing the name of the executable.;T@!o; ;[I"EA library like OptionParser can be used to process command-line ;TI"arguments.;T; @â; 0@â@@@0U; [iI"RUBY_VERSION;TI"Object::RUBY_VERSION;T00o;;[o; ;[I" The running version of ruby;T; I"version.c;T; 0@ú@@@0U; [iI"RUBY_RELEASE_DATE;TI"Object::RUBY_RELEASE_DATE;T00o;;[o; ;[I"$The date this ruby was released;T; @ú; 0@ú@@@0U; [iI"RUBY_PLATFORM;TI"Object::RUBY_PLATFORM;T00o;;[o; ;[I"The platform for this ruby;T; @ú; 0@ú@@@0U; [iI"RUBY_PATCHLEVEL;TI"Object::RUBY_PATCHLEVEL;T00o;;[o; ;[I"KThe patchlevel for this ruby. If this is a development build of ruby ;TI"the patchlevel will be -1;T; @ú; 0@ú@@@0U; [iI"RUBY_REVISION;TI"Object::RUBY_REVISION;T00o;;[o; ;[I"$The SVN revision for this ruby.;T; @ú; 0@ú@@@0U; [iI"RUBY_DESCRIPTION;TI"Object::RUBY_DESCRIPTION;T00o;;[o; ;[I"@The full ruby version string, like ruby -v prints';T; @ú; 0@ú@@@0U; [iI"RUBY_COPYRIGHT;TI"Object::RUBY_COPYRIGHT;T00o;;[o; ;[I""The copyright string for ruby;T; @ú; 0@ú@@@0U; [iI"RUBY_ENGINE;TI"Object::RUBY_ENGINE;T00o;;[o; ;[I".The engine or interpreter this ruby uses.;T; @ú; 0@ú@@@0U; [iI"TOPLEVEL_BINDING;TI"Object::TOPLEVEL_BINDING;T00o;;[o; ;[I"'The Binding of the top level scope;T; I" vm.c;T; 0@D@@@0[[I"Benchmark;To;;[; I"lib/benchmark.rb;T; 0I"lib/benchmark.rb;T[I"MakeMakefile;To;;[; I"lib/mkmf.rb;T; 0I"lib/mkmf.rb;T[I" Kernel;To;;[; @1; 0I" object.c;T[[I" class;T[[: public[[I" yaml_tag;FI"$ext/psych/lib/psych/core_ext.rb;T[:protected[[: private[[I" instance;T[[;[?[I"!~;T@V[I"<=>;T@V[I"===;T@V[I"=~;T@V[I"CSV;FI"lib/csv.rb;T[I"DelegateClass;FI"lib/delegate.rb;T[I" Digest;FI"ext/digest/lib/digest.rb;T[I" class;T@V[I" clone;T@V[I" dclone;FI"lib/rexml/xpath_parser.rb;T[I"default_src_encoding;FI"lib/irb/src_encoding.rb;T[I"define_singleton_method;TI" proc.c;T[I" display;TI" io.c;T[I"dup;T@V[I" enum_for;TI"enumerator.c;T[I" eql?;T@V[I" extend;TI" eval.c;T[I" freeze;T@V[I" frozen?;T@V[I" hash;T@V[I" inspect;T@V[I"instance_of?;T@V[I"instance_variable_defined?;T@V[I"instance_variable_get;T@V[I"instance_variable_set;T@V[I"instance_variables;T@V[I" is_a?;T@V[I" kind_of?;T@V[I" method;T@†[I" methods;T@V[I" nil?;T@V[I"object_id;TI" gc.c;T[I"private_methods;T@V[I"protected_methods;T@V[I"psych_to_yaml;F@_[I"public_method;T@†[I"public_methods;T@V[I"public_send;TI"vm_eval.c;T[I"remove_instance_variable;T@V[I"respond_to?;TI"vm_method.c;T[I"respond_to_missing?;T@Ä[I" send;T@¿[I"singleton_class;T@V[I"singleton_method;T@†[I"singleton_methods;T@V[I" sysread;FI"*lib/webrick/httpservlet/cgi_runner.rb;T[I" taint;T@V[I" tainted?;T@V[I"tap;T@V[I" timeout;FI"lib/timeout.rb;T[I" to_enum;T@Ž[I" to_s;T@V[I" to_yaml;T@_[I" trust;T@V[I" untaint;T@V[I" untrust;T@V[I"untrusted?;T@V[I"xmp;FI"lib/irb/xmp.rb;T[;[[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[3@ I"enumerator.c;TI" eval.c;TI"ext/digest/lib/digest.rb;T@@@?I" gc.c;T@M@WI"lib/English.rb;T@JI"lib/csv.rb;TI"lib/debug.rb;TI"lib/delegate.rb;TI"lib/drb/drb.rb;T@I"lib/irb/src_encoding.rb;TI"lib/irb/xmp.rb;TI"lib/mathn.rb;TI"lib/minitest/mock.rb;TI"lib/minitest/spec.rb;TI"lib/minitest/unit.rb;T@PI"lib/pp.rb;T@~I"lib/rake.rb;TI"lib/rake/clean.rb;TI""lib/rake/contrib/publisher.rb;T@I"lib/rubygems/syck_hack.rb;T@„@¨@³I"lib/tracer.rb;TI"lib/un.rb;TI"*lib/webrick/httpservlet/cgi_runner.rb;TI"lib/yaml.rb;T@1I" parse.c;TI" proc.c;T@â@ú@DI"vm_eval.c;TI"vm_method.c;T@cRDoc::TopLevelnil%3f-i.ri000064400000000777152410544230006421 0ustar00U:RDoc::AnyMethod[iI" nil?:ETI"Object#nil?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"POnly the object nil responds true to nil?.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"!Object.new.nil? #=> false ;TI"nil.nil? #=> true;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"-obj.nil? -> true or false ;T0[I"();T@FI" Object;TcRDoc::NormalClass00class-i.ri000064400000001077152410544230006440 0ustar00U:RDoc::AnyMethod[iI" class:ETI"Object#class;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"AReturns the class of obj. This method must always be ;TI"Gcalled with an explicit receiver, as class is also a ;TI"reserved word in Ruby.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"1.class #=> Fixnum ;TI"self.class #=> Object;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.class -> class ;T0[I"();T@FI" Object;TcRDoc::NormalClass00method-i.ri000064400000002011152410544230006600 0ustar00U:RDoc::AnyMethod[iI" method:ETI"Object#method;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"HLooks up the named method as a receiver in obj, returning a ;TI"IMethod object (or raising NameError). The ;TI"IMethod object acts as a closure in obj's object ;TI"Hinstance, so instance variables and the value of self ;TI"remain available.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"class Demo ;TI" def initialize(n) ;TI" @iv = n ;TI" end ;TI" def hello() ;TI" "Hello, @iv = #{@iv}" ;TI" end ;TI" end ;TI" ;TI"k = Demo.new(99) ;TI"m = k.method(:hello) ;TI"$m.call #=> "Hello, @iv = 99" ;TI" ;TI"l = Demo.new('Fred') ;TI"m = l.method("hello") ;TI"%m.call #=> "Hello, @iv = Fred";T: @format0: @fileI" proc.c;T:0@omit_headings_from_table_of_contents_below0I""obj.method(sym) -> method ;T0[I" (p1);T@%FI" Object;TcRDoc::NormalClass00define_singleton_method-i.ri000064400000002037152410544230012204 0ustar00U:RDoc::AnyMethod[iI"define_singleton_method:ETI"#Object#define_singleton_method;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I">Defines a singleton method in the receiver. The _method_ ;TI"Iparameter can be a +Proc+, a +Method+ or an +UnboundMethod+ object. ;TI" "I am: A" ;TI" ;TI"guy = "Bob" ;TI"Eguy.define_singleton_method(:hello) { "#{self}: Hello there!" } ;TI"*guy.hello #=> "Bob: Hello there!";T: @format0: @fileI" proc.c;T:0@omit_headings_from_table_of_contents_below0I"mdefine_singleton_method(symbol, method) -> new_method define_singleton_method(symbol) { block } -> proc ;T0[I" (*args);T@"FI" Object;TcRDoc::NormalClass00taint-i.ri000064400000001645152410544230006453 0ustar00U:RDoc::AnyMethod[iI" taint:ETI"Object#taint;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I" Mark the object as tainted.;To:RDoc::Markup::BlankLineo; ; [ I"QObjects that are marked as tainted will be restricted from various built-in ;TI"Omethods. This is to prevent insecure data, such as command-line arguments ;TI"Ror strings read from Kernel#gets, from inadvertently compromising the user's ;TI" system.;T@o; ; [I":To check whether an object is tainted, use #tainted?.;T@o; ; [I"PYou should only untaint a tainted object if your code has inspected it and ;TI"7determined that it is safe. To do so use #untaint.;T@o; ; [I"SIn $SAFE level 3, all newly created objects are tainted and you can't untaint ;TI" objects.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.taint -> obj ;T0[I"();T@ FI" Object;TcRDoc::NormalClass00instance_variable_set-i.ri000064400000002221152410544230011647 0ustar00U:RDoc::AnyMethod[iI"instance_variable_set:ETI"!Object#instance_variable_set;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"DSets the instance variable named by symbol to the given ;TI" "dog" ;TI"8fred.instance_variable_set(:@c, 'cat') #=> "cat" ;TI"dfred.inspect #=> "#";T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"gobj.instance_variable_set(symbol, obj) -> obj obj.instance_variable_set(string, obj) -> obj ;T0[I" (p1, p2);T@FI" Object;TcRDoc::NormalClass00public_method-i.ri000064400000000554152410544230010150 0ustar00U:RDoc::AnyMethod[iI"public_method:ETI"Object#public_method;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"6Similar to _method_, searches public method only.;T: @fileI" proc.c;T:0@omit_headings_from_table_of_contents_below0I")obj.public_method(sym) -> method ;T0[I" (p1);T@FI" Object;TcRDoc::NormalClass00tainted%3f-i.ri000064400000000636152410544230007261 0ustar00U:RDoc::AnyMethod[iI" tainted?:ETI"Object#tainted?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"+Returns true if the object is tainted.;To:RDoc::Markup::BlankLineo; ; [I"%See #taint for more information.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"&obj.tainted? -> true or false ;T0[I"();T@FI" Object;TcRDoc::NormalClass00%3d%3d%3d-i.ri000064400000000746152410544230006500 0ustar00U:RDoc::AnyMethod[iI"===:ETI"Object#===;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"HCase Equality -- For class Object, effectively the same as calling ;TI"J#==, but typically overridden by descendants to provide ;TI"/meaningful semantics in +case+ statements.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"&obj === other -> true or false ;T0[I" (p1);T@FI" Object;TcRDoc::NormalClass00clone-i.ri000064400000002216152410544230006427 0ustar00U:RDoc::AnyMethod[iI" clone:ETI"Object#clone;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [ I"GProduces a shallow copy of obj---the instance variables of ;TI"@obj are copied, but not the objects they reference. ;TI"Kclone copies the frozen and tainted state of obj. ;TI";See also the discussion under Object#dup.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"class Klass ;TI" attr_accessor :str ;TI" end ;TI"1s1 = Klass.new #=> # ;TI"%s1.str = "Hello" #=> "Hello" ;TI">s2 = s1.clone #=> # ;TI"!s2.str[1,4] = "i" #=> "i" ;TI"?s1.inspect #=> "#" ;TI"?s2.inspect #=> "#" ;T: @format0o; ; [I"@This method may have class-specific behavior. If so, that ;TI"Hbehavior will be documented under the #+initialize_copy+ method of ;TI"the class.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.clone -> an_object ;T0[I"();T@"FI" Object;TcRDoc::NormalClass00ParseError/cdesc-ParseError.ri000064400000000622152410544230012327 0ustar00U:RDoc::NormalClass[iI"ParseError:EFI"Object::ParseError;TI"StandardError;To:RDoc::Markup::Document: @parts[o;;[: @fileI"lib/racc/parser.rb;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [[; [[; [[[U:RDoc::Context::Section[i0o;;[; 0; 0[@I" Object;TcRDoc::NormalClassmethods-i.ri000064400000002420152410544230006767 0ustar00U:RDoc::AnyMethod[iI" methods:ETI"Object#methods;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"DReturns a list of the names of public and protected methods of ;FI"Aobj. This will include all the methods accessible in ;FI"obj's ancestors. ;FI"CIf the regular parameter is set to false, ;FI"GReturns an array of obj's public and protected singleton methods, ;FI"Jthe array will not include methods in modules included in obj.;Fo:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"class Klass ;TI" def klass_method() ;TI" end ;TI" end ;TI"k = Klass.new ;TI"9k.methods[0..9] #=> [:klass_method, :nil?, :===, ;TI"- # :==~, :!, :eql? ;TI"D # :hash, :<=>, :class, :singleton_class] ;TI"k.methods.length #=> 57 ;TI" ;TI"k.methods(false) #=> [] ;TI"!def k.singleton_method; end ;TI"0k.methods(false) #=> [:singleton_method] ;TI" ;TI"$module M123; def m123; end end ;TI"k.extend M123 ;TI"/k.methods(false) #=> [:singleton_method];T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"+obj.methods(regular=true) -> array ;F0[I" (p1);T@'FI" Object;TcRDoc::NormalClass00instance_of%3f-i.ri000064400000001311152410544230010110 0ustar00U:RDoc::AnyMethod[iI"instance_of?:ETI"Object#instance_of?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"IReturns true if obj is an instance of the given ;TI"2class. See also Object#kind_of?.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"class A; end ;TI"class B < A; end ;TI"class C < B; end ;TI" ;TI"b = B.new ;TI""b.instance_of? A #=> false ;TI"!b.instance_of? B #=> true ;TI"!b.instance_of? C #=> false;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"1obj.instance_of?(class) -> true or false ;T0[I" (p1);T@FI" Object;TcRDoc::NormalClass00singleton_class-i.ri000064400000001623152410544230010517 0ustar00U:RDoc::AnyMethod[iI"singleton_class:ETI"Object#singleton_class;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"EReturns the singleton class of obj. This method creates ;TI";a new singleton class if obj does not have one.;To:RDoc::Markup::BlankLineo; ; [ I">If obj is nil, true, or ;TI"Hfalse, it returns NilClass, TrueClass, or FalseClass, ;TI"respectively. ;TI"BIf obj is a Fixnum or a Symbol, it raises a TypeError.;T@o:RDoc::Markup::Verbatim; [I"CObject.new.singleton_class #=> #> ;TI"5String.singleton_class #=> # ;TI"-nil.singleton_class #=> NilClass;T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"%obj.singleton_class -> class ;T0[I"();T@FI" Object;TcRDoc::NormalClass00object_id-i.ri000064400000001305152410544230007247 0ustar00U:RDoc::AnyMethod[iI"object_id:ETI"Object#object_id;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"-Returns an integer identifier for +obj+.;To:RDoc::Markup::BlankLineo; ; [I"OThe same number will be returned on all calls to +id+ for a given object, ;TI"0and no two active objects will share an id.;T@o; ; [I"NObject#object_id is a different concept from the +:name+ notation, which ;TI"%returns the symbol id of +name+.;T@o; ; [I"'Replaces the deprecated Object#id.;T: @fileI" gc.c;T:0@omit_headings_from_table_of_contents_below0I"=obj.__id__ -> integer obj.object_id -> integer ;T0[I"();T@FI" Object;TcRDoc::NormalClass00to_yaml-i.ri000064400000000432152410544230006771 0ustar00U:RDoc::AnyMethod[iI" to_yaml:ETI"Object#to_yaml;TF: publico:RDoc::Markup::Document: @parts[: @fileI"$ext/psych/lib/psych/core_ext.rb;T:0@omit_headings_from_table_of_contents_below000[I"(options = {});T@ FI" Object;TcRDoc::NormalClass0[@FI"psych_to_yaml;Ftap-i.ri000064400000001477152410544230006123 0ustar00U:RDoc::AnyMethod[iI"tap:ETI"Object#tap;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"6Yields self to the block, and then returns self. ;TI"IThe primary purpose of this method is to "tap into" a method chain, ;TI"Min order to perform operations on intermediate results within the chain.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"E(1..10) .tap {|x| puts "original: #{x.inspect}"} ;TI"B .to_a .tap {|x| puts "array: #{x.inspect}"} ;TI"B .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"} ;TI"C .map {|x| x*x} .tap {|x| puts "squares: #{x.inspect}"};T: @format0: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj.tap{|x|...} -> obj ;T0[I"();T@FI" Object;TcRDoc::NormalClass00%3c%3d%3e-i.ri000064400000001720152410544230006471 0ustar00U:RDoc::AnyMethod[iI"<=>:ETI"Object#<=>;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"8Returns 0 if +obj+ and +other+ are the same object ;TI"1or obj == other, otherwise nil.;To:RDoc::Markup::BlankLineo; ; [I"HThe <=> is used by various methods to compare objects, for example ;TI")Enumerable#sort, Enumerable#max etc.;T@o; ; [ I"RYour implementation of <=> should return one of the following values: -1, 0, ;TI"T1 or nil. -1 means self is smaller than other. 0 means self is equal to other. ;TI"N1 means self is bigger than other. Nil means the two values could not be ;TI"compared.;T@o; ; [I"OWhen you define <=>, you can include Comparable to gain the methods <=, <,;TS:RDoc::Markup::Heading: leveli: textI", >=, > and between?.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"obj <=> other -> 0 or nil ;T0[I" (p1);T@FI" Object;TcRDoc::NormalClass00hash-i.ri000064400000001651152410544230006254 0ustar00U:RDoc::AnyMethod[iI" hash:ETI"Object#hash;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"QGenerates a Fixnum hash value for this object. This function must have the ;TI"Pproperty that a.eql?(b) implies a.hash == b.hash.;To:RDoc::Markup::BlankLineo; ; [I"OThe hash value is used along with #eql? by the Hash class to determine if ;TI"Otwo objects reference the same hash key. Any hash value that exceeds the ;TI">capacity of a Fixnum will be truncated before being used.;T@o; ; [ I"MThe hash value for an object may not be identical across invocations or ;TI"Kimplementations of Ruby. If you need a stable identifier across Ruby ;TI"Qinvocations and implementations you will need to generate one with a custom ;TI" method.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below000[I"();T@FI" Object;TcRDoc::NormalClass00DelegateClass-i.ri000064400000002571152410544230010033 0ustar00U:RDoc::AnyMethod[iI"DelegateClass:EFI"Object#DelegateClass;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"SThe primary interface to this library. Use to setup delegation when defining ;TI"your class.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"?class MyClass < DelegateClass(ClassToDelegateTo) # Step 1 ;TI" def initialize ;TI"? super(obj_of_ClassToDelegateTo) # Step 2 ;TI" end ;TI" end ;T: @format0o; ; [ I"OHere's a sample of use from Tempfile which is really a File object with a ;TI"Jfew special rules about storage location and when the File should be ;TI"Odeleted. That makes for an almost textbook perfect example of how to use ;TI"delegation.;T@o; ; [I"*class Tempfile < DelegateClass(File) ;TI": # constant and class member data initialization... ;TI" ;TI"4 def initialize(basename, tmpdir=Dir::tmpdir) ;TI"5 # build up file path/name in var tmpname... ;TI" ;TI"P @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600) ;TI" ;TI" # ... ;TI" ;TI" super(@tmpfile) ;TI" ;TI"B # below this point, all methods of File are supported... ;TI" end ;TI" ;TI" # ... ;TI"end;T; 0: @fileI"lib/delegate.rb;T:0@omit_headings_from_table_of_contents_below000[I"(superclass);T@0TI" Object;TcRDoc::NormalClass00TimeoutError/catch-c.ri000064400000000367152410544230011050 0ustar00U:RDoc::AnyMethod[iI" catch:EFI"Timeout::Error::catch;TT: publico:RDoc::Markup::Document: @parts[: @fileI"lib/timeout.rb;T:0@omit_headings_from_table_of_contents_below00I"exc;T[I" (*args);T@ FI" Error;TcRDoc::NormalClass00TimeoutError/exception-i.ri000064400000000361152410544230011764 0ustar00U:RDoc::AnyMethod[iI"exception:EFI"Timeout::Error#exception;TF: publico:RDoc::Markup::Document: @parts[: @fileI"lib/timeout.rb;T:0@omit_headings_from_table_of_contents_below000[I"(*);T@ FI" Error;TcRDoc::NormalClass00TimeoutError/cdesc-TimeoutError.ri000064400000001075152410544230013262 0ustar00U:RDoc::NormalClass[iI"TimeoutError:EFI"Object::TimeoutError;TI"RuntimeError;To:RDoc::Markup::Document: @parts[o;;[o:RDoc::Markup::Paragraph;[I"8Raised by Timeout#timeout when the block times out.;T: @fileI"lib/timeout.rb;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[ I" thread;TI"R;T: publicFI"lib/timeout.rb;T[[[[I" class;T[[; [[I" catch;F@[:protected[[: private[[I" instance;T[[; [[I"exception;F@[; [[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[@I" Object;TcRDoc::NormalClassTimeoutError/thread-i.ri000064400000000347152410544230011241 0ustar00U:RDoc::Attr[iI" thread:ETI"Timeout::Error#thread;TI"R;T: publico:RDoc::Markup::Document: @parts[: @fileI"lib/timeout.rb;T:0@omit_headings_from_table_of_contents_below0F@ I"Timeout::Error;TcRDoc::NormalClass0%21%7e-i.ri000064400000000600152410544230006112 0ustar00U:RDoc::AnyMethod[iI"!~:ETI"Object#!~;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"CReturns true if two objects do not match (using the =~ ;TI"method), otherwise false.;T: @fileI" object.c;T:0@omit_headings_from_table_of_contents_below0I"$obj !~ other -> true or false ;T0[I" (p1);T@FI" Object;TcRDoc::NormalClass00