Object
is the default root of all Ruby objects. Object
inherits from BasicObject
which allows creating alternate object hierarchies. Methods on Object
are available to all classes unless explicitly overridden.
Object
mixes in the Kernel module, making the built-in kernel functions globally accessible. Although the instance methods of Object
are defined by the Kernel module, we have chosen to document them here for clarity.
When referencing constants in classes inheriting from Object
you do not need to use the full namespace. For example, referencing File
inside YourClass
will find the top-level File
class.
In the descriptions of Object's methods, the parameter symbol refers to a symbol, which is either a quoted string or a Symbol
(such as :name
).
ARGF
is a stream designed for use in scripts that process files given as command-line arguments or passed in via STDIN
.
See ARGF
(the class) for more details.
ARGV
contains the command line arguments used to run ruby.
A library like OptionParser can be used to process command-line arguments.
DATA
is a File
that contains the data section of the executed file. To create a data section use __END__
:
$ cat t.rb puts DATA.gets __END__ hello world! $ ruby t.rb hello world!
ENV
is a Hash-like accessor for environment variables.
See ENV
(the class) for more details.
An obsolete alias of false
An obsolete alias of nil
The copyright string for ruby
The full ruby version string, like ruby -v
prints'
The engine or interpreter this ruby uses.
The version of the engine or interpreter this ruby uses.
The patchlevel for this ruby. If this is a development build of ruby the patchlevel will be -1
The platform for this ruby
The date this ruby was released
The SVN revision for this ruby.
The running version of ruby
When a Hash
is assigned to SCRIPT_LINES__
the contents of files loaded after the assignment will be added as an Array
of lines with the file name as the key.
Holds the original stderr
Holds the original stdin
Holds the original stdout
The Binding of the top level scope
An obsolete alias of true
Returns true if two objects do not match (using the =~ method), otherwise false.
static VALUE rb_obj_not_match(VALUE obj1, VALUE obj2) { VALUE result = rb_funcall(obj1, id_match, 1, obj2); return RTEST(result) ? Qfalse : Qtrue; }
Returns 0 if obj
and other
are the same object or obj == other
, otherwise nil.
The <=>
is used by various methods to compare objects, for example Enumerable#sort
, Enumerable#max
etc.
Your implementation of <=>
should return one of the following values: -1, 0, 1 or nil. -1 means self is smaller than other. 0 means self is equal to other. 1 means self is bigger than other. Nil means the two values could not be compared.
When you define <=>
, you can include Comparable
to gain the methods <=
, <
, ==
, >=
, >
and between?
.
static VALUE rb_obj_cmp(VALUE obj1, VALUE obj2) { if (obj1 == obj2 || rb_equal(obj1, obj2)) return INT2FIX(0); return Qnil; }
Case Equality – For class Object
, effectively the same as calling #==
, but typically overridden by descendants to provide meaningful semantics in case
statements.
VALUE rb_equal(VALUE obj1, VALUE obj2) { VALUE result; if (obj1 == obj2) return Qtrue; result = rb_equal_opt(obj1, obj2); if (result == Qundef) { result = rb_funcall(obj1, id_eq, 1, obj2); } if (RTEST(result)) return Qtrue; return Qfalse; }
Pattern Match—Overridden by descendants (notably Regexp
and String
) to provide meaningful pattern-match semantics.
static VALUE rb_obj_match(VALUE obj1, VALUE obj2) { return Qnil; }
# File golf_prelude.rb, line 43 def callable_methods self.class == Object ? methods + private_methods : methods end
Returns the class of obj. This method must always be called with an explicit receiver, as class
is also a reserved word in Ruby.
1.class #=> Integer self.class #=> Object
VALUE rb_obj_class(VALUE obj) { return rb_class_real(CLASS_OF(obj)); }
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. clone
copies the frozen (unless :freeze keyword argument is given with a false value) and tainted state of obj. See also the discussion under Object#dup
.
class Klass attr_accessor :str end s1 = Klass.new #=> #<Klass:0x401b3a38> s1.str = "Hello" #=> "Hello" s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello"> s2.str[1,4] = "i" #=> "i" s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">" s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">"
This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy
method of the class.
static VALUE rb_obj_clone2(int argc, VALUE *argv, VALUE obj) { int kwfreeze = freeze_opt(argc, argv); if (!special_object_p(obj)) return mutable_obj_clone(obj, kwfreeze); return immutable_obj_clone(obj, kwfreeze); }
Defines a singleton method in the receiver. The method parameter can be a Proc
, a Method
or an UnboundMethod
object. If a block is specified, it is used as the method body.
class A class << self def class_name to_s end end end A.define_singleton_method(:who_am_i) do "I am: #{class_name}" end A.who_am_i # ==> "I am: A" guy = "Bob" guy.define_singleton_method(:hello) { "#{self}: Hello there!" } guy.hello #=> "Bob: Hello there!"
static VALUE rb_obj_define_method(int argc, VALUE *argv, VALUE obj) { VALUE klass = rb_singleton_class(obj); return rb_mod_define_method(argc, argv, klass); }
Prints obj on the given port (default $>
). Equivalent to:
def display(port=$>) port.write self nil end
For example:
1.display "cat".display [ 4, 5, 6 ].display puts
produces:
1cat[4, 5, 6]
static VALUE rb_obj_display(int argc, VALUE *argv, VALUE self) { VALUE out; if (argc == 0) { out = rb_stdout; } else { rb_scan_args(argc, argv, "01", &out); } rb_io_write(out, self); return Qnil; }
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. dup
copies the tainted state of obj.
This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy
method of the class.
In general, clone
and dup
may have different semantics in descendant classes. While clone
is used to duplicate an object, including its internal state, dup
typically uses the class of the descendant object to create the new instance.
When using dup
, any modules that the object has been extended with will not be copied.
class Klass attr_accessor :str end module Foo def foo; 'foo'; end end s1 = Klass.new #=> #<Klass:0x401b3a38> s1.extend(Foo) #=> #<Klass:0x401b3a38> s1.foo #=> "foo" s2 = s1.clone #=> #<Klass:0x401b3a38> s2.foo #=> "foo" s3 = s1.dup #=> #<Klass:0x401b3a38> s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401b3a38>
VALUE rb_obj_dup(VALUE obj) { VALUE dup; if (special_object_p(obj)) { return obj; } dup = rb_obj_alloc(rb_obj_class(obj)); init_copy(dup, obj); rb_funcall(dup, id_init_dup, 1, obj); return dup; }
Creates a new Enumerator
which will enumerate by calling method
on obj
, passing args
if any.
If a block is given, it will be used to calculate the size of the enumerator without the need to iterate it (see Enumerator#size
).
str = "xyz" enum = str.enum_for(:each_byte) enum.each { |b| puts b } # => 120 # => 121 # => 122 # protect an array from being modified by some_method a = [1, 2, 3] some_method(a.to_enum)
It is typical to call to_enum
when defining methods for a generic Enumerable
, in case no block is passed.
Here is such an example, with parameter passing and a sizing block:
module Enumerable # a generic method to repeat the values of any enumerable def repeat(n) raise ArgumentError, "#{n} is negative!" if n < 0 unless block_given? return to_enum(__method__, n) do # __method__ is :repeat here sz = size # Call size and multiply by n... sz * n if sz # but return nil if size itself is nil end end each do |*val| n.times { yield *val } end end end %i[hello world].repeat(2) { |w| puts w } # => Prints 'hello', 'hello', 'world', 'world' enum = (1..14).repeat(3) # => returns an Enumerator when called without a block enum.first(4) # => [1, 1, 1, 2] enum.size # => 42
static VALUE obj_to_enum(int argc, VALUE *argv, VALUE obj) { VALUE enumerator, meth = sym_each; if (argc > 0) { --argc; meth = *argv++; } enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0); if (rb_block_given_p()) { enumerator_ptr(enumerator)->size = rb_block_proc(); } return enumerator; }
Equality — At the Object
level, ==
returns true
only if obj
and other
are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.
Unlike ==
, the equal?
method should never be overridden by subclasses as it is used to determine object identity (that is, a.equal?(b)
if and only if a
is the same object as b
):
obj = "a" other = obj.dup obj == other #=> true obj.equal? other #=> false obj.equal? obj #=> true
The eql?
method returns true
if obj
and other
refer to the same hash key. This is used by Hash
to test members for equality. For objects of class Object
, eql?
is synonymous with ==
. Subclasses normally continue this tradition by aliasing eql?
to their overridden ==
method, but there are exceptions. Numeric
types, for example, perform type conversion across ==
, but not across eql?
, so:
1 == 1.0 #=> true 1.eql? 1.0 #=> false
VALUE rb_obj_equal(VALUE obj1, VALUE obj2) { if (obj1 == obj2) return Qtrue; return Qfalse; }
Adds to obj the instance methods from each module given as a parameter.
module Mod def hello "Hello from Mod.\n" end end class Klass def hello "Hello from Klass.\n" end end k = Klass.new k.hello #=> "Hello from Klass.\n" k.extend(Mod) #=> #<Klass:0x401b3bc8> k.hello #=> "Hello from Mod.\n"
static VALUE rb_obj_extend(int argc, VALUE *argv, VALUE obj) { int i; ID id_extend_object, id_extended; CONST_ID(id_extend_object, "extend_object"); CONST_ID(id_extended, "extended"); rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); for (i = 0; i < argc; i++) Check_Type(argv[i], T_MODULE); while (argc--) { rb_funcall(argv[argc], id_extend_object, 1, obj); rb_funcall(argv[argc], id_extended, 1, obj); } return obj; }
Prevents further modifications to obj. A RuntimeError
will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also Object#frozen?
.
This method returns self.
a = [ "a", "b", "c" ] a.freeze a << "z"
produces:
prog.rb:3:in `<<': can't modify frozen Array (FrozenError) from prog.rb:3
Objects of the following classes are always frozen: Integer
, Float
, Symbol
.
VALUE rb_obj_freeze(VALUE obj) { if (!OBJ_FROZEN(obj)) { OBJ_FREEZE(obj); if (SPECIAL_CONST_P(obj)) { rb_bug("special consts should be frozen."); } } return obj; }
Returns the freeze status of obj.
a = [ "a", "b", "c" ] a.freeze #=> ["a", "b", "c"] a.frozen? #=> true
VALUE rb_obj_frozen_p(VALUE obj) { return OBJ_FROZEN(obj) ? Qtrue : Qfalse; }
Returns a string containing a human-readable representation of obj. The default inspect
shows the object's class name, an encoding of the object id, and a list of the instance variables and their values (by calling inspect
on each of them). User defined classes should override this method to provide a better representation of obj. When overriding this method, it should return a string whose encoding is compatible with the default external encoding.
[ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]" Time.new.inspect #=> "2008-03-08 19:43:39 +0900" class Foo end Foo.new.inspect #=> "#<Foo:0x0300c868>" class Bar def initialize @bar = 1 end end Bar.new.inspect #=> "#<Bar:0x0300c868 @bar=1>"
static VALUE rb_obj_inspect(VALUE obj) { if (rb_ivar_count(obj) > 0) { VALUE str; VALUE c = rb_class_name(CLASS_OF(obj)); str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void*)obj); return rb_exec_recursive(inspect_obj, obj, str); } else { return rb_any_to_s(obj); } }
Returns true
if obj is an instance of the given class. See also Object#kind_of?
.
class A; end class B < A; end class C < B; end b = B.new b.instance_of? A #=> false b.instance_of? B #=> true b.instance_of? C #=> false
VALUE rb_obj_is_instance_of(VALUE obj, VALUE c) { c = class_or_module_required(c); if (rb_obj_class(obj) == c) return Qtrue; return Qfalse; }
Returns true
if the given instance variable is defined in obj. String
arguments are converted to symbols.
class Fred def initialize(p1, p2) @a, @b = p1, p2 end end fred = Fred.new('cat', 99) fred.instance_variable_defined?(:@a) #=> true fred.instance_variable_defined?("@b") #=> true fred.instance_variable_defined?("@c") #=> false
static VALUE rb_obj_ivar_defined(VALUE obj, VALUE iv) { ID id = id_for_var(obj, iv, an, instance); if (!id) { return Qfalse; } return rb_ivar_defined(obj, id); }
Returns the value of the given instance variable, or nil if the instance variable is not set. The @
part of the variable name should be included for regular instance variables. Throws a NameError
exception if the supplied symbol is not valid as an instance variable name. String
arguments are converted to symbols.
class Fred def initialize(p1, p2) @a, @b = p1, p2 end end fred = Fred.new('cat', 99) fred.instance_variable_get(:@a) #=> "cat" fred.instance_variable_get("@b") #=> 99
static VALUE rb_obj_ivar_get(VALUE obj, VALUE iv) { ID id = id_for_var(obj, iv, an, instance); if (!id) { return Qnil; } return rb_ivar_get(obj, id); }
Sets the instance variable named by symbol to the given object, thereby frustrating the efforts of the class's author to attempt to provide proper encapsulation. The variable does not have to exist prior to this call. If the instance variable name is passed as a string, that string is converted to a symbol.
class Fred def initialize(p1, p2) @a, @b = p1, p2 end end fred = Fred.new('cat', 99) fred.instance_variable_set(:@a, 'dog') #=> "dog" fred.instance_variable_set(:@c, 'cat') #=> "cat" fred.inspect #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
static VALUE rb_obj_ivar_set(VALUE obj, VALUE iv, VALUE val) { ID id = id_for_var(obj, iv, an, instance); if (!id) id = rb_intern_str(iv); return rb_ivar_set(obj, id, val); }
Returns an array of instance variable names for the receiver. Note that simply defining an accessor does not create the corresponding instance variable.
class Fred attr_accessor :a1 def initialize @iv = 3 end end Fred.new.instance_variables #=> [:@iv]
VALUE rb_obj_instance_variables(VALUE obj) { VALUE ary; ary = rb_ary_new(); rb_ivar_foreach(obj, ivar_i, ary); return ary; }
Returns true
if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.
module M; end class A include M end class B < A; end class C < B; end b = B.new b.is_a? A #=> true b.is_a? B #=> true b.is_a? C #=> false b.is_a? M #=> true b.kind_of? A #=> true b.kind_of? B #=> true b.kind_of? C #=> false b.kind_of? M #=> true
VALUE rb_obj_is_kind_of(VALUE obj, VALUE c) { VALUE cl = CLASS_OF(obj); c = class_or_module_required(c); return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse; }
Returns the receiver.
string = "my string" string.itself.object_id == string.object_id #=> true
static VALUE rb_obj_itself(VALUE obj) { return obj; }
Returns true
if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.
module M; end class A include M end class B < A; end class C < B; end b = B.new b.is_a? A #=> true b.is_a? B #=> true b.is_a? C #=> false b.is_a? M #=> true b.kind_of? A #=> true b.kind_of? B #=> true b.kind_of? C #=> false b.kind_of? M #=> true
VALUE rb_obj_is_kind_of(VALUE obj, VALUE c) { VALUE cl = CLASS_OF(obj); c = class_or_module_required(c); return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse; }
# File golf_prelude.rb, line 16 def matching_methods(s = '', m = callable_methods) r = /^#{s.to_s.gsub(/./){"(.*?)" + Regexp.escape($&)}}/ m.grep(r).sort_by do |i| i.to_s.match(r).captures.map(&:size) << i end end
Looks up the named method as a receiver in obj, returning a Method
object (or raising NameError
). The Method
object acts as a closure in obj's object instance, so instance variables and the value of self
remain available.
class Demo def initialize(n) @iv = n end def hello() "Hello, @iv = #{@iv}" end end k = Demo.new(99) m = k.method(:hello) m.call #=> "Hello, @iv = 99" l = Demo.new('Fred') m = l.method("hello") m.call #=> "Hello, @iv = Fred"
VALUE rb_obj_method(VALUE obj, VALUE vid) { return obj_method(obj, vid, FALSE); }
# File golf_prelude.rb, line 4 def method_missing m, *a, &b t = @@golf_hash[ [m, self.class] ] ||= matching_methods(m)[0] if t && b __send__(t, *a) {|*args| b.binding.eval("proc{|golf_matchdata| $~ = golf_matchdata }").call($~) if $~ b.call(*args) } else t ? __send__(t, *a, &b) : super end end
Returns a list of the names of public and protected methods of obj. This will include all the methods accessible in obj's ancestors. If the optional parameter is false
, it returns an array of obj<i>'s public and protected singleton methods, the array will not include methods in modules included in <i>obj.
class Klass def klass_method() end end k = Klass.new k.methods[0..9] #=> [:klass_method, :nil?, :===, # :==~, :!, :eql? # :hash, :<=>, :class, :singleton_class] k.methods.length #=> 56 k.methods(false) #=> [] def k.singleton_method; end k.methods(false) #=> [:singleton_method] module M123; def m123; end end k.extend M123 k.methods(false) #=> [:singleton_method]
VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj) { rb_check_arity(argc, 0, 1); if (argc > 0 && !RTEST(argv[0])) { return rb_obj_singleton_methods(argc, argv, obj); } return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i); }
Only the object nil responds true
to nil?
.
Object.new.nil? #=> false nil.nil? #=> true
static VALUE rb_false(VALUE obj) { return Qfalse; }
Returns an integer identifier for obj
.
The same number will be returned on all calls to object_id
for a given object, and no two active objects will share an id.
Note: that some objects of builtin classes are reused for optimization. This is the case for immediate values and frozen string literals.
Immediate values are not passed by reference but are passed by value: nil
, true
, false
, Fixnums, Symbols, and some Floats.
Object.new.object_id == Object.new.object_id # => false (21 * 2).object_id == (21 * 2).object_id # => true "hello".object_id == "hello".object_id # => false "hi".freeze.object_id == "hi".freeze.object_id # => true
VALUE rb_obj_id(VALUE obj) { /* * 32-bit VALUE space * MSB ------------------------ LSB * false 00000000000000000000000000000000 * true 00000000000000000000000000000010 * nil 00000000000000000000000000000100 * undef 00000000000000000000000000000110 * symbol ssssssssssssssssssssssss00001110 * object oooooooooooooooooooooooooooooo00 = 0 (mod sizeof(RVALUE)) * fixnum fffffffffffffffffffffffffffffff1 * * object_id space * LSB * false 00000000000000000000000000000000 * true 00000000000000000000000000000010 * nil 00000000000000000000000000000100 * undef 00000000000000000000000000000110 * symbol 000SSSSSSSSSSSSSSSSSSSSSSSSSSS0 S...S % A = 4 (S...S = s...s * A + 4) * object oooooooooooooooooooooooooooooo0 o...o % A = 0 * fixnum fffffffffffffffffffffffffffffff1 bignum if required * * where A = sizeof(RVALUE)/4 * * sizeof(RVALUE) is * 20 if 32-bit, double is 4-byte aligned * 24 if 32-bit, double is 8-byte aligned * 40 if 64-bit */ if (STATIC_SYM_P(obj)) { return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG; } else if (FLONUM_P(obj)) { #if SIZEOF_LONG == SIZEOF_VOIDP return LONG2NUM((SIGNED_VALUE)obj); #else return LL2NUM((SIGNED_VALUE)obj); #endif } else if (SPECIAL_CONST_P(obj)) { return LONG2NUM((SIGNED_VALUE)obj); } return nonspecial_obj_id(obj); }
Returns the list of private methods accessible to obj. If the all parameter is set to false
, only those methods in the receiver will be listed.
VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj) { return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i); }
Returns the list of protected methods accessible to obj. If the all parameter is set to false
, only those methods in the receiver will be listed.
VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj) { return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_i); }
Similar to method, searches public method only.
VALUE rb_obj_public_method(VALUE obj, VALUE vid) { return obj_method(obj, vid, TRUE); }
Returns the list of public methods accessible to obj. If the all parameter is set to false
, only those methods in the receiver will be listed.
VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj) { return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_pub_i); }
Invokes the method identified by symbol, passing it any arguments specified. Unlike send, public_send
calls public methods only. When the method is identified by a string, the string is converted to a symbol.
1.public_send(:puts, "hello") # causes NoMethodError
static VALUE rb_f_public_send(int argc, VALUE *argv, VALUE recv) { return send_internal(argc, argv, recv, CALL_PUBLIC); }
Removes the named instance variable from obj, returning that variable's value.
class Dummy attr_reader :var def initialize @var = 99 end def remove remove_instance_variable(:@var) end end d = Dummy.new d.var #=> 99 d.remove #=> 99 d.var #=> nil
VALUE rb_obj_remove_instance_variable(VALUE obj, VALUE name) { VALUE val = Qnil; const ID id = id_for_var(obj, name, an, instance); st_data_t n, v; struct st_table *iv_index_tbl; st_data_t index; rb_check_frozen(obj); if (!id) { goto not_defined; } switch (BUILTIN_TYPE(obj)) { case T_OBJECT: iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj); if (!iv_index_tbl) break; if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) break; if (ROBJECT_NUMIV(obj) <= index) break; val = ROBJECT_IVPTR(obj)[index]; if (val != Qundef) { ROBJECT_IVPTR(obj)[index] = Qundef; return val; } break; case T_CLASS: case T_MODULE: n = id; if (RCLASS_IV_TBL(obj) && st_delete(RCLASS_IV_TBL(obj), &n, &v)) { return (VALUE)v; } break; default: if (FL_TEST(obj, FL_EXIVAR)) { if (generic_ivar_remove(obj, id, &val)) { return val; } } break; } not_defined: rb_name_err_raise("instance variable %1$s not defined", obj, name); UNREACHABLE; }
Returns true
if obj responds to the given method. Private and protected methods are included in the search only if the optional second parameter evaluates to true
.
If the method is not implemented, as Process.fork
on Windows, File.lchmod
on GNU/Linux, etc., false is returned.
If the method is not defined, respond_to_missing?
method is called and the result is returned.
When the method name parameter is given as a string, the string is converted to a symbol.
static VALUE obj_respond_to(int argc, VALUE *argv, VALUE obj) { VALUE mid, priv; ID id; rb_execution_context_t *ec = GET_EC(); rb_scan_args(argc, argv, "11", &mid, &priv); if (!(id = rb_check_id(&mid))) { VALUE ret = basic_obj_respond_to_missing(ec, CLASS_OF(obj), obj, rb_to_symbol(mid), priv); if (ret == Qundef) ret = Qfalse; return ret; } if (basic_obj_respond_to(ec, obj, id, !RTEST(priv))) return Qtrue; return Qfalse; }
DO NOT USE THIS DIRECTLY.
Hook method to return whether the obj can respond to id method or not.
When the method name parameter is given as a string, the string is converted to a symbol.
See respond_to?
, and the example of BasicObject
.
static VALUE obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv) { return Qfalse; }
Invokes the method identified by symbol, passing it any arguments specified. You can use __send__
if the name send
clashes with an existing method in obj. When the method is identified by a string, the string is converted to a symbol.
class Klass def hello(*args) "Hello " + args.join(' ') end end k = Klass.new k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
VALUE rb_f_send(int argc, VALUE *argv, VALUE recv) { return send_internal(argc, argv, recv, CALL_FCALL); }
# File golf_prelude.rb, line 29 def shortest_abbreviation(s = '', m = callable_methods) s = s.to_s our_case = (?A..?Z) === s[0] if m.index(s.to_sym) 1.upto(s.size){|z| s.scan(/./).combination(z).map{|trial| next unless ((?A..?Z) === trial[0]) == our_case trial *= '' return trial if matching_methods(trial, m)[0].to_s == s }} else nil end end
Returns the singleton class of obj. This method creates a new singleton class if obj does not have one.
If obj is nil
, true
, or false
, it returns NilClass
, TrueClass
, or FalseClass
, respectively. If obj is an Integer
, a Float
or a Symbol
, it raises a TypeError
.
Object.new.singleton_class #=> #<Class:#<Object:0xb7ce1e24>> String.singleton_class #=> #<Class:String> nil.singleton_class #=> NilClass
static VALUE rb_obj_singleton_class(VALUE obj) { return rb_singleton_class(obj); }
Similar to method, searches singleton method only.
class Demo def initialize(n) @iv = n end def hello() "Hello, @iv = #{@iv}" end end k = Demo.new(99) def k.hi "Hi, @iv = #{@iv}" end m = k.singleton_method(:hi) m.call #=> "Hi, @iv = 99" m = k.singleton_method(:hello) #=> NameError
VALUE rb_obj_singleton_method(VALUE obj, VALUE vid) { const rb_method_entry_t *me; VALUE klass = rb_singleton_class_get(obj); ID id = rb_check_id(&vid); if (NIL_P(klass) || NIL_P(klass = RCLASS_ORIGIN(klass))) { undef: rb_name_err_raise("undefined singleton method `%1$s' for `%2$s'", obj, vid); } if (!id) { if (respond_to_missing_p(klass, obj, vid, FALSE)) { id = rb_intern_str(vid); return mnew_missing(klass, obj, id, rb_cMethod); } goto undef; } me = rb_method_entry_at(klass, id); if (UNDEFINED_METHOD_ENTRY_P(me) || UNDEFINED_REFINED_METHOD_P(me->def)) { vid = ID2SYM(id); goto undef; } return mnew_from_me(me, klass, klass, obj, id, rb_cMethod, FALSE); }
Returns an array of the names of singleton methods for obj. If the optional all parameter is true, the list will include methods in modules included in obj. Only public and protected singleton methods are returned.
module Other def three() end end class Single def Single.four() end end a = Single.new def a.one() end class << a include Other def two() end end Single.singleton_methods #=> [:four] a.singleton_methods(false) #=> [:two, :one] a.singleton_methods #=> [:two, :one, :three]
VALUE rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj) { VALUE recur, ary, klass, origin; struct method_entry_arg me_arg; struct rb_id_table *mtbl; if (argc == 0) { recur = Qtrue; } else { rb_scan_args(argc, argv, "01", &recur); } klass = CLASS_OF(obj); origin = RCLASS_ORIGIN(klass); me_arg.list = st_init_numtable(); me_arg.recur = RTEST(recur); if (klass && FL_TEST(klass, FL_SINGLETON)) { if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg); klass = RCLASS_SUPER(klass); } if (RTEST(recur)) { while (klass && (FL_TEST(klass, FL_SINGLETON) || RB_TYPE_P(klass, T_ICLASS))) { if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg); klass = RCLASS_SUPER(klass); } } ary = rb_ary_new(); st_foreach(me_arg.list, ins_methods_i, ary); st_free_table(me_arg.list); return ary; }
Mark the object as tainted.
Objects that are marked as tainted will be restricted from various built-in methods. This is to prevent insecure data, such as command-line arguments or strings read from Kernel#gets
, from inadvertently compromising the user's system.
To check whether an object is tainted, use tainted?
.
You should only untaint a tainted object if your code has inspected it and determined that it is safe. To do so use untaint
.
VALUE rb_obj_taint(VALUE obj) { if (!OBJ_TAINTED(obj) && OBJ_TAINTABLE(obj)) { rb_check_frozen(obj); OBJ_TAINT(obj); } return obj; }
Returns true if the object is tainted.
See taint
for more information.
VALUE rb_obj_tainted(VALUE obj) { if (OBJ_TAINTED(obj)) return Qtrue; return Qfalse; }
Yields self to the block, and then returns self. The primary purpose of this method is to “tap into” a method chain, in order to perform operations on intermediate results within the chain.
(1..10) .tap {|x| puts "original: #{x}" } .to_a .tap {|x| puts "array: #{x}" } .select {|x| x.even? } .tap {|x| puts "evens: #{x}" } .map {|x| x*x } .tap {|x| puts "squares: #{x}" }
VALUE rb_obj_tap(VALUE obj) { rb_yield(obj); return obj; }
Creates a new Enumerator
which will enumerate by calling method
on obj
, passing args
if any.
If a block is given, it will be used to calculate the size of the enumerator without the need to iterate it (see Enumerator#size
).
str = "xyz" enum = str.enum_for(:each_byte) enum.each { |b| puts b } # => 120 # => 121 # => 122 # protect an array from being modified by some_method a = [1, 2, 3] some_method(a.to_enum)
It is typical to call to_enum
when defining methods for a generic Enumerable
, in case no block is passed.
Here is such an example, with parameter passing and a sizing block:
module Enumerable # a generic method to repeat the values of any enumerable def repeat(n) raise ArgumentError, "#{n} is negative!" if n < 0 unless block_given? return to_enum(__method__, n) do # __method__ is :repeat here sz = size # Call size and multiply by n... sz * n if sz # but return nil if size itself is nil end end each do |*val| n.times { yield *val } end end end %i[hello world].repeat(2) { |w| puts w } # => Prints 'hello', 'hello', 'world', 'world' enum = (1..14).repeat(3) # => returns an Enumerator when called without a block enum.first(4) # => [1, 1, 1, 2] enum.size # => 42
static VALUE obj_to_enum(int argc, VALUE *argv, VALUE obj) { VALUE enumerator, meth = sym_each; if (argc > 0) { --argc; meth = *argv++; } enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0); if (rb_block_given_p()) { enumerator_ptr(enumerator)->size = rb_block_proc(); } return enumerator; }
Returns a string representing obj. The default to_s
prints the object's class and an encoding of the object id. As a special case, the top-level object that is the initial execution context of Ruby programs returns “main''.
VALUE rb_any_to_s(VALUE obj) { VALUE str; VALUE cname = rb_class_name(CLASS_OF(obj)); str = rb_sprintf("#<%"PRIsVALUE":%p>", cname, (void*)obj); OBJ_INFECT(str, obj); return str; }
Deprecated method that is equivalent to untaint
.
VALUE rb_obj_trust(VALUE obj) { rb_warning("trust is deprecated and its behavior is same as untaint"); return rb_obj_untaint(obj); }
Removes the tainted mark from the object.
See taint
for more information.
VALUE rb_obj_untaint(VALUE obj) { if (OBJ_TAINTED(obj)) { rb_check_frozen(obj); FL_UNSET(obj, FL_TAINT); } return obj; }
Deprecated method that is equivalent to taint
.
VALUE rb_obj_untrust(VALUE obj) { rb_warning("untrust is deprecated and its behavior is same as taint"); return rb_obj_taint(obj); }
Deprecated method that is equivalent to tainted?
.
VALUE rb_obj_untrusted(VALUE obj) { rb_warning("untrusted? is deprecated and its behavior is same as tainted?"); return rb_obj_tainted(obj); }
Yields self to the block and returns the result of the block.
"my string".yield_self {|s| s.upcase } #=> "MY STRING" 3.next.yield_self {|x| x**x }.to_s #=> "256"
static VALUE rb_obj_yield_self(VALUE obj) { RETURN_SIZED_ENUMERATOR(obj, 0, 0, rb_obj_size); return rb_yield_values2(1, &obj); }