Class: Object
Overview
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
).
Instance Method Summary collapse
-
#!~ ⇒ Object
Returns true if two objects do not match (using the =~ method), otherwise false.
-
#<=>(other) ⇒ 0?
Returns 0 if
obj
andother
are the same object orobj == other
, otherwise nil. -
#===(other) ⇒ Boolean
Case Equality – For class Object, effectively the same as calling
#==
, but typically overridden by descendants to provide meaningful semantics incase
statements. -
#=~(other) ⇒ nil
Pattern Match—Overridden by descendants (notably
Regexp
andString
) to provide meaningful pattern-match semantics. -
#assert_Qundef ⇒ Object
:nodoc:.
-
#class ⇒ Class
Returns the class of obj.
-
#clone ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.
-
#define_singleton_method ⇒ Object
Defines a singleton method in the receiver.
-
#display(port = $>) ⇒ nil
Prints obj on the given port (default
$>
). -
#dup ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.
-
#enum_for ⇒ Object
Creates a new Enumerator which will enumerate by calling
method
onobj
, passingargs
if any. -
#eql? ⇒ Boolean
Equality — At the
Object
level,==
returnstrue
only ifobj
andother
are the same object. -
#extend ⇒ Object
Adds to obj the instance methods from each module given as a parameter.
-
#freeze ⇒ Object
Prevents further modifications to obj.
-
#frozen? ⇒ Boolean
Returns the freeze status of obj.
-
#hash ⇒ Object
Generates a Fixnum hash value for this object.
-
#initialize_clone ⇒ Object
:nodoc:.
-
#initialize_copy ⇒ Object
:nodoc:.
-
#initialize_dup ⇒ Object
:nodoc:.
-
#inspect ⇒ String
Returns a string containing a human-readable representation of obj.
-
#instance_of? ⇒ Boolean
Returns
true
if obj is an instance of the given class. -
#instance_variable_defined? ⇒ Boolean
Returns
true
if the given instance variable is defined in obj. -
#instance_variable_get ⇒ Object
Returns the value of the given instance variable, or nil if the instance variable is not set.
-
#instance_variable_set ⇒ Object
Sets the instance variable names by symbol to object, thereby frustrating the efforts of the class’s author to attempt to provide proper encapsulation.
-
#instance_variables ⇒ Array
Returns an array of instance variable names for the receiver.
-
#is_a? ⇒ Boolean
Returns
true
if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj. -
#kind_of? ⇒ Boolean
Returns
true
if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj. -
#method(sym) ⇒ Object
Looks up the named method as a receiver in obj, returning a
Method
object (or raisingNameError
). -
#methods(regular = true) ⇒ Array
Returns a list of the names of public and protected methods of obj.
-
#nil? ⇒ Boolean
Only the object nil responds
true
tonil?
. -
#hash ⇒ Fixnum
Generates a Fixnum hash value for this object.
-
#private_methods(all = true) ⇒ Array
Returns the list of private methods accessible to obj.
-
#protected_methods(all = true) ⇒ Array
Returns the list of protected methods accessible to obj.
-
#public_method(sym) ⇒ Object
Similar to method, searches public method only.
-
#public_methods(all = true) ⇒ Array
Returns the list of public methods accessible to obj.
-
#public_send ⇒ Object
Invokes the method identified by symbol, passing it any arguments specified.
-
#rawVALUE ⇒ Object
:nodoc:.
-
#remove_instance_variable(symbol) ⇒ Object
Removes the named instance variable from obj, returning that variable’s value.
-
#respond_to? ⇒ Boolean
Returns
true
if obj responds to the given method. -
#respond_to_missing? ⇒ Boolean
DO NOT USE THIS DIRECTLY.
-
#send ⇒ Object
Invokes the method identified by symbol, passing it any arguments specified.
-
#singleton_class ⇒ Class
Returns the singleton class of obj.
-
#singleton_method(sym) ⇒ Object
Similar to method, searches singleton method only.
-
#singleton_methods(all = true) ⇒ Array
Returns an array of the names of singleton methods for obj.
-
#taint ⇒ Object
Mark the object as tainted.
-
#tainted? ⇒ Boolean
Returns true if the object is tainted.
-
#tap {|x| ... } ⇒ Object
Yields
x
to the block, and then returnsx
. -
#to_enum ⇒ Object
Creates a new Enumerator which will enumerate by calling
method
onobj
, passingargs
if any. -
#to_s ⇒ String
Returns a string representing obj.
-
#trust ⇒ Object
Deprecated method that is equivalent to #untaint.
-
#untaint ⇒ Object
Removes the tainted mark from the object.
-
#untrust ⇒ Object
Deprecated method that is equivalent to #taint.
-
#untrusted? ⇒ Boolean
Deprecated method that is equivalent to #tainted?.
-
#validate_object ⇒ Object
:nodoc:.
Methods included from Kernel
#Array, #Complex, #Float, #Hash, #Integer, #Rational, #String, #__callee__, #__dir__, #__method__, #`, #abort, #at_exit, #autoload, #autoload?, #binding, #block_given?, #caller, #caller_locations, #catch, #eval, #exec, #exit, #exit!, #fail, #fork, #format, #gets, #global_variables, #iterator?, #lambda, #load, #local_variables, #loop, #open, #p, #print, #printf, #proc, #putc, #puts, #raise, #rand, #readline, #readlines, #require, #require_relative, #select, #set_trace_func, #sleep, #spawn, #sprintf, #srand, #syscall, #system, #test, #throw, #trace_var, #trap, #untrace_var, #warn
Instance Method Details
#!~ ⇒ Object
Returns true if two objects do not match (using the =~ method), otherwise false.
1391 1392 1393 1394 1395 1396 |
# File 'object.c', line 1391
static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
VALUE result = rb_funcall(obj1, id_match, 1, obj2);
return RTEST(result) ? Qfalse : Qtrue;
}
|
#<=>(other) ⇒ 0?
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?.
1417 1418 1419 1420 1421 1422 1423 |
# File 'object.c', line 1417
static VALUE
rb_obj_cmp(VALUE obj1, VALUE obj2)
{
if (obj1 == obj2 || rb_equal(obj1, obj2))
return INT2FIX(0);
return Qnil;
}
|
#===(other) ⇒ Boolean
Case Equality – For class Object, effectively the same as calling #==
, but typically overridden by descendants to provide meaningful semantics in case
statements.
88 89 90 91 92 93 94 95 96 97 |
# File 'object.c', line 88
VALUE
rb_equal(VALUE obj1, VALUE obj2)
{
VALUE result;
if (obj1 == obj2) return Qtrue;
result = rb_funcall(obj1, id_eq, 1, obj2);
if (RTEST(result)) return Qtrue;
return Qfalse;
}
|
#=~(other) ⇒ nil
Pattern Match—Overridden by descendants (notably Regexp
and String
) to provide meaningful pattern-match semantics.
1377 1378 1379 1380 1381 |
# File 'object.c', line 1377
static VALUE
rb_obj_match(VALUE obj1, VALUE obj2)
{
return Qnil;
}
|
#assert_Qundef ⇒ Object
:nodoc:
11547 11548 11549 11550 11551 11552 11553 11554 11555 |
# File 'parse.y', line 11547
static VALUE
ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
{
StringValue(msg);
if (obj == Qundef) {
rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
}
return Qnil;
}
|
#class ⇒ Class
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 #=> Fixnum
self.class #=> Object
226 227 228 229 230 |
# File 'object.c', line 226
VALUE
rb_obj_class(VALUE obj)
{
return rb_class_real(CLASS_OF(obj));
}
|
#clone ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. Copies the frozen 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.
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 |
# File 'object.c', line 328
VALUE
rb_obj_clone(VALUE obj)
{
VALUE clone;
VALUE singleton;
if (rb_special_const_p(obj)) {
rb_raise(rb_eTypeError, "can't clone %s", rb_obj_classname(obj));
}
clone = rb_obj_alloc(rb_obj_class(obj));
RBASIC(clone)->flags &= (FL_TAINT|FL_PROMOTED|FL_WB_PROTECTED);
RBASIC(clone)->flags |= RBASIC(obj)->flags & ~(FL_PROMOTED|FL_FREEZE|FL_FINALIZE|FL_WB_PROTECTED);
singleton = rb_singleton_class_clone_and_attach(obj, clone);
RBASIC_SET_CLASS(clone, singleton);
if (FL_TEST(singleton, FL_SINGLETON)) {
rb_singleton_class_attached(singleton, clone);
}
init_copy(clone, obj);
rb_funcall(clone, id_init_clone, 1, obj);
RBASIC(clone)->flags |= RBASIC(obj)->flags & FL_FREEZE;
return clone;
}
|
#define_singleton_method(symbol, method) ⇒ Object #define_singleton_method(symbol) { ... } ⇒ Proc
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!"
1716 1717 1718 1719 1720 1721 1722 |
# File 'proc.c', line 1716
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);
}
|
#display(port = $>) ⇒ nil
Prints obj on the given port (default $>
). Equivalent to:
def display(port=$>)
port.write self
end
For example:
1.display
"cat".display
[ 4, 5, 6 ].display
puts
produces:
1cat456
7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 |
# File 'io.c', line 7101
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;
}
|
#dup ⇒ Object
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.
on dup vs clone
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>
397 398 399 400 401 402 403 404 405 406 407 408 409 410 |
# File 'object.c', line 397
VALUE
rb_obj_dup(VALUE obj)
{
VALUE dup;
if (rb_special_const_p(obj)) {
rb_raise(rb_eTypeError, "can't dup %s", rb_obj_classname(obj));
}
dup = rb_obj_alloc(rb_obj_class(obj));
init_copy(dup, obj);
rb_funcall(dup, id_init_dup, 1, obj);
return dup;
}
|
#to_enum(method = :each, *args) ⇒ Enumerator #enum_for(method = :each, *args) ⇒ Enumerator #to_enum(method = :each, *args) {|*args| ... } ⇒ Enumerator #enum_for(method = :each, *args) {|*args| ... } ⇒ Enumerator
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).
Examples
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
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 |
# File 'enumerator.c', line 241
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;
}
|
#==(other) ⇒ Boolean #equal?(other) ⇒ Boolean #eql?(other) ⇒ Boolean
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
141 142 143 144 145 146 |
# File 'object.c', line 141
VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
if (obj1 == obj2) return Qtrue;
return Qfalse;
}
|
#extend ⇒ Object
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"
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 |
# File 'eval.c', line 1373
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;
}
|
#freeze ⇒ Object
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 (RuntimeError)
from prog.rb:3
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 |
# File 'object.c', line 1053
VALUE
rb_obj_freeze(VALUE obj)
{
if (!OBJ_FROZEN(obj)) {
OBJ_FREEZE(obj);
if (SPECIAL_CONST_P(obj)) {
if (!immediate_frozen_tbl) {
immediate_frozen_tbl = st_init_numtable();
}
st_insert(immediate_frozen_tbl, obj, (st_data_t)Qtrue);
}
}
return obj;
}
|
#frozen? ⇒ Boolean
Returns the freeze status of obj.
a = [ "a", "b", "c" ]
a.freeze #=> ["a", "b", "c"]
a.frozen? #=> true
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 |
# File 'object.c', line 1079
VALUE
rb_obj_frozen_p(VALUE obj)
{
if (OBJ_FROZEN(obj)) return Qtrue;
if (SPECIAL_CONST_P(obj)) {
if (!immediate_frozen_tbl) return Qfalse;
if (st_lookup(immediate_frozen_tbl, obj, 0)) return Qtrue;
}
return Qfalse;
}
|
#hash ⇒ Object
Generates a Fixnum hash value for this object. This function must have the property that a.eql?(b)
implies a.hash == b.hash
.
The hash value is used along with #eql? by the Hash class to determine if two objects reference the same hash key. Any hash value that exceeds the capacity of a Fixnum will be truncated before being used.
The hash value for an object may not be identical across invocations or implementations of ruby. If you need a stable identifier across ruby invocations and implementations you will need to generate one with a custom method.
161 162 163 164 165 166 167 168 169 170 171 172 173 174 |
# File 'object.c', line 161
VALUE
rb_obj_hash(VALUE obj)
{
VALUE oid = rb_obj_id(obj);
#if SIZEOF_LONG == SIZEOF_VOIDP
st_index_t index = NUM2LONG(oid);
#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
st_index_t index = NUM2LL(oid);
#else
# error not supported
#endif
st_index_t h = rb_hash_end(rb_hash_start(index));
return LONG2FIX(h);
}
|
#initialize_clone ⇒ Object
:nodoc:
426 427 428 429 430 431 |
# File 'object.c', line 426
VALUE
rb_obj_init_dup_clone(VALUE obj, VALUE orig)
{
rb_funcall(obj, id_init_copy, 1, orig);
return obj;
}
|
#initialize_copy ⇒ Object
:nodoc:
413 414 415 416 417 418 419 420 421 422 423 |
# File 'object.c', line 413
VALUE
rb_obj_init_copy(VALUE obj, VALUE orig)
{
if (obj == orig) return obj;
rb_check_frozen(obj);
rb_check_trusted(obj);
if (TYPE(obj) != TYPE(orig) || rb_obj_class(obj) != rb_obj_class(orig)) {
rb_raise(rb_eTypeError, "initialize_copy should take same class object");
}
return obj;
}
|
#initialize_dup ⇒ Object
:nodoc:
426 427 428 429 430 431 |
# File 'object.c', line 426
VALUE
rb_obj_init_dup_clone(VALUE obj, VALUE orig)
{
rb_funcall(obj, id_init_copy, 1, orig);
return obj;
}
|
#inspect ⇒ String
Returns a string containing a human-readable representation of obj. By default, show the class name and the list of the instance variables and their values (by calling #inspect on each of them). User defined classes should override this method to make 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>"
class Baz
def to_s
"baz"
end
end
Baz.new.inspect #=> "#<Baz:0x0300c868>"
555 556 557 558 559 560 561 562 563 564 565 566 567 568 |
# File 'object.c', line 555
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);
}
}
|
#instance_of? ⇒ Boolean
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
604 605 606 607 608 609 610 |
# File 'object.c', line 604
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;
}
|
#instance_variable_defined?(symbol) ⇒ Boolean #instance_variable_defined?(string) ⇒ Boolean
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
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 |
# File 'object.c', line 2403
static VALUE
rb_obj_ivar_defined(VALUE obj, VALUE iv)
{
ID id = rb_check_id(&iv);
if (!id) {
if (rb_is_instance_name(iv)) {
return Qfalse;
}
else {
rb_name_error_str(iv, "`%"PRIsVALUE"' is not allowed as an instance variable name",
QUOTE(iv));
}
}
if (!rb_is_instance_id(id)) {
rb_name_error(id, "`%"PRIsVALUE"' is not allowed as an instance variable name",
QUOTE_ID(id));
}
return rb_ivar_defined(obj, id);
}
|
#instance_variable_get(symbol) ⇒ Object #instance_variable_get(string) ⇒ Object
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
2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 |
# File 'object.c', line 2332
static VALUE
rb_obj_ivar_get(VALUE obj, VALUE iv)
{
ID id = rb_check_id(&iv);
if (!id) {
if (rb_is_instance_name(iv)) {
return Qnil;
}
else {
rb_name_error_str(iv, "`%"PRIsVALUE"' is not allowed as an instance variable name",
QUOTE(iv));
}
}
if (!rb_is_instance_id(id)) {
rb_name_error(id, "`%"PRIsVALUE"' is not allowed as an instance variable name",
QUOTE_ID(id));
}
return rb_ivar_get(obj, id);
}
|
#instance_variable_set(symbol, obj) ⇒ Object #instance_variable_set(string, obj) ⇒ Object
Sets the instance variable names by symbol to object, thereby frustrating the efforts of the class’s author to attempt to provide proper encapsulation. The variable did 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\">"
2376 2377 2378 2379 2380 2381 |
# File 'object.c', line 2376
static VALUE
rb_obj_ivar_set(VALUE obj, VALUE iv, VALUE val)
{
ID id = id_for_setter(iv, instance, "`%"PRIsVALUE"' is not allowed as an instance variable name");
return rb_ivar_set(obj, id, val);
}
|
#instance_variables ⇒ Array
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]
1370 1371 1372 1373 1374 1375 1376 1377 1378 |
# File 'variable.c', line 1370
VALUE
rb_obj_instance_variables(VALUE obj)
{
VALUE ary;
ary = rb_ary_new();
rb_ivar_foreach(obj, ivar_i, ary);
return ary;
}
|
#is_a? ⇒ Boolean #kind_of? ⇒ Boolean
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
641 642 643 644 645 646 647 648 649 650 651 652 653 654 |
# File 'object.c', line 641
VALUE
rb_obj_is_kind_of(VALUE obj, VALUE c)
{
VALUE cl = CLASS_OF(obj);
c = class_or_module_required(c);
c = RCLASS_ORIGIN(c);
while (cl) {
if (cl == c || RCLASS_M_TBL_WRAPPER(cl) == RCLASS_M_TBL_WRAPPER(c))
return Qtrue;
cl = RCLASS_SUPER(cl);
}
return Qfalse;
}
|
#is_a? ⇒ Boolean #kind_of? ⇒ Boolean
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
641 642 643 644 645 646 647 648 649 650 651 652 653 654 |
# File 'object.c', line 641
VALUE
rb_obj_is_kind_of(VALUE obj, VALUE c)
{
VALUE cl = CLASS_OF(obj);
c = class_or_module_required(c);
c = RCLASS_ORIGIN(c);
while (cl) {
if (cl == c || RCLASS_M_TBL_WRAPPER(cl) == RCLASS_M_TBL_WRAPPER(c))
return Qtrue;
cl = RCLASS_SUPER(cl);
}
return Qfalse;
}
|
#method(sym) ⇒ Object
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"
1455 1456 1457 1458 1459 1460 1461 1462 1463 |
# File 'proc.c', line 1455
VALUE
rb_obj_method(VALUE obj, VALUE vid)
{
ID id = rb_check_id(&vid);
if (!id) {
rb_method_name_error(CLASS_OF(obj), vid);
}
return mnew(CLASS_OF(obj), obj, id, rb_cMethod, FALSE);
}
|
#methods(regular = true) ⇒ Array
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 regular parameter is set to false
, Returns an array of obj’s public and protected singleton methods, the array will not include methods in modules included in 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 #=> 57
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]
1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 |
# File 'class.c', line 1289
VALUE
rb_obj_methods(int argc, VALUE *argv, VALUE obj)
{
retry:
if (argc == 0) {
return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i);
}
else {
VALUE recur;
rb_scan_args(argc, argv, "1", &recur);
if (RTEST(recur)) {
argc = 0;
goto retry;
}
return rb_obj_singleton_methods(argc, argv, obj);
}
}
|
#nil? ⇒ true #< ⇒ false
Only the object nil responds true
to nil?
.
1361 1362 1363 1364 1365 |
# File 'object.c', line 1361
static VALUE
rb_false(VALUE obj)
{
return Qfalse;
}
|
#hash ⇒ Fixnum
Generates a Fixnum hash value for this object.
This function must have the property that a.eql?(b)
implies a.hash == b.hash
.
The hash value is used by Hash class.
Any hash value that exceeds the capacity of a Fixnum will be truncated before being used.
2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 |
# File 'gc.c', line 2364
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 (SYMBOL_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);
}
|
#private_methods(all = true) ⇒ Array
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.
1332 1333 1334 1335 1336 |
# File 'class.c', line 1332
VALUE
rb_obj_private_methods(int argc, VALUE *argv, VALUE obj)
{
return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i);
}
|
#protected_methods(all = true) ⇒ Array
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.
1317 1318 1319 1320 1321 |
# File 'class.c', line 1317
VALUE
rb_obj_protected_methods(int argc, VALUE *argv, VALUE obj)
{
return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_i);
}
|
#public_method(sym) ⇒ Object
Similar to method, searches public method only.
1472 1473 1474 1475 1476 1477 1478 1479 1480 |
# File 'proc.c', line 1472
VALUE
rb_obj_public_method(VALUE obj, VALUE vid)
{
ID id = rb_check_id(&vid);
if (!id) {
rb_method_name_error(CLASS_OF(obj), vid);
}
return mnew(CLASS_OF(obj), obj, id, rb_cMethod, TRUE);
}
|
#public_methods(all = true) ⇒ Array
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.
1347 1348 1349 1350 1351 |
# File 'class.c', line 1347
VALUE
rb_obj_public_methods(int argc, VALUE *argv, VALUE obj)
{
return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_pub_i);
}
|
#public_send(symbol[, args...]) ⇒ Object #public_send(string[, args...]) ⇒ Object
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
927 928 929 930 931 |
# File 'vm_eval.c', line 927
VALUE
rb_f_public_send(int argc, VALUE *argv, VALUE recv)
{
return send_internal(argc, argv, recv, CALL_PUBLIC);
}
|
#rawVALUE ⇒ Object
:nodoc:
11558 11559 11560 11561 11562 |
# File 'parse.y', line 11558
static VALUE
ripper_value(VALUE self, VALUE obj)
{
return ULONG2NUM(obj);
}
|
#remove_instance_variable(symbol) ⇒ Object
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
1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 |
# File 'variable.c', line 1402
VALUE
rb_obj_remove_instance_variable(VALUE obj, VALUE name)
{
VALUE val = Qnil;
const ID id = rb_check_id(&name);
st_data_t n, v;
struct st_table *iv_index_tbl;
st_data_t index;
rb_check_frozen(obj);
if (!id) {
if (rb_is_instance_name(name)) {
rb_name_error_str(name, "instance variable %"PRIsVALUE" not defined",
name);
}
else {
rb_name_error_str(name, "`%"PRIsVALUE"' is not allowed as an instance variable name",
QUOTE(name));
}
}
if (!rb_is_instance_id(id)) {
rb_name_error(id, "`%"PRIsVALUE"' is not allowed as an instance variable name",
QUOTE_ID(id));
}
if (SPECIAL_CONST_P(obj)) goto generic;
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) <= (long)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:
generic:
if (FL_TEST(obj, FL_EXIVAR) || rb_special_const_p(obj)) {
v = val;
if (generic_ivar_remove(obj, (st_data_t)id, &v)) {
return (VALUE)v;
}
}
break;
}
rb_name_error(id, "instance variable %"PRIsVALUE" not defined", QUOTE_ID(id));
UNREACHABLE;
}
|
#respond_to?(symbol, include_all = false) ⇒ Boolean #respond_to?(string, include_all = false) ⇒ Boolean
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.
1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 |
# File 'vm_method.c', line 1656
static VALUE
obj_respond_to(int argc, VALUE *argv, VALUE obj)
{
VALUE mid, priv;
ID id;
rb_scan_args(argc, argv, "11", &mid, &priv);
if (!(id = rb_check_id(&mid))) {
if (!rb_method_basic_definition_p(CLASS_OF(obj), idRespond_to_missing)) {
VALUE args[2];
args[0] = ID2SYM(rb_to_id(mid));
args[1] = priv;
return rb_funcall2(obj, idRespond_to_missing, 2, args);
}
return Qfalse;
}
if (basic_obj_respond_to(obj, id, !RTEST(priv)))
return Qtrue;
return Qfalse;
}
|
#respond_to_missing?(symbol, include_all) ⇒ Boolean #respond_to_missing?(string, include_all) ⇒ Boolean
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.
1692 1693 1694 1695 1696 |
# File 'vm_method.c', line 1692
static VALUE
obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
{
return Qfalse;
}
|
#send(symbol[, args...]) ⇒ Object #__send__(symbol[, args...]) ⇒ Object #send(string[, args...]) ⇒ Object #__send__(string[, args...]) ⇒ Object
Invokes the method identified by symbol, passing it any
arguments specified. You can use <code>__send__</code> 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"
907 908 909 910 911 |
# File 'vm_eval.c', line 907
VALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
return send_internal(argc, argv, recv, CALL_FCALL);
}
|
#singleton_class ⇒ Class
Returns the singleton class of obj. This method creates a new singleton class if obj does not have it.
If obj is nil
, true
, or false
, it returns NilClass, TrueClass, or FalseClass, respectively. If obj is a Fixnum or a Symbol, it raises a TypeError.
Object.new.singleton_class #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class #=> #<Class:String>
nil.singleton_class #=> NilClass
249 250 251 252 253 |
# File 'object.c', line 249
static VALUE
rb_obj_singleton_class(VALUE obj)
{
return rb_singleton_class(obj);
}
|
#singleton_method(sym) ⇒ Object
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
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 |
# File 'proc.c', line 1506
VALUE
rb_obj_singleton_method(VALUE obj, VALUE vid)
{
rb_method_entry_t *me;
VALUE klass;
ID id = rb_check_id(&vid);
if (!id) {
rb_name_error_str(vid, "undefined singleton method `%"PRIsVALUE"' for `%"PRIsVALUE"'",
QUOTE(vid), obj);
}
if (NIL_P(klass = rb_singleton_class_get(obj)) ||
!(me = rb_method_entry_at(klass, id))) {
rb_name_error(id, "undefined singleton method `%"PRIsVALUE"' for `%"PRIsVALUE"'",
QUOTE_ID(id), obj);
}
return mnew_from_me(me, klass, klass, obj, id, rb_cMethod, FALSE);
}
|
#singleton_methods(all = true) ⇒ Array
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]
1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 |
# File 'class.c', line 1386
VALUE
rb_obj_singleton_methods(int argc, VALUE *argv, VALUE obj)
{
VALUE recur, ary, klass, origin;
st_table *list, *mtbl;
if (argc == 0) {
recur = Qtrue;
}
else {
rb_scan_args(argc, argv, "01", &recur);
}
klass = CLASS_OF(obj);
origin = RCLASS_ORIGIN(klass);
list = st_init_numtable();
if (klass && FL_TEST(klass, FL_SINGLETON)) {
if ((mtbl = RCLASS_M_TBL(origin)) != 0)
st_foreach(mtbl, method_entry_i, (st_data_t)list);
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)
st_foreach(mtbl, method_entry_i, (st_data_t)list);
klass = RCLASS_SUPER(klass);
}
}
ary = rb_ary_new();
st_foreach(list, ins_methods_i, ary);
st_free_table(list);
return ary;
}
|
#taint ⇒ Object
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 users 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
In $SAFE level 3, all newly created objects are tainted and you can’t untaint objects.
950 951 952 953 954 955 956 957 958 |
# File 'object.c', line 950
VALUE
rb_obj_taint(VALUE obj)
{
if (!OBJ_TAINTED(obj)) {
rb_check_frozen(obj);
OBJ_TAINT(obj);
}
return obj;
}
|
#tainted? ⇒ Boolean
Returns true if the object is tainted.
See #taint for more information.
922 923 924 925 926 927 928 |
# File 'object.c', line 922
VALUE
rb_obj_tainted(VALUE obj)
{
if (OBJ_TAINTED(obj))
return Qtrue;
return Qfalse;
}
|
#tap {|x| ... } ⇒ Object
Yields x
to the block, and then returns x
. 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.inspect}”}
.to_a .tap {|x| puts "array: #{x.inspect}"}
.select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
.map { |x| x*x } .tap {|x| puts "squares: #{x.inspect}"}
672 673 674 675 676 677 |
# File 'object.c', line 672
VALUE
rb_obj_tap(VALUE obj)
{
rb_yield(obj);
return obj;
}
|
#to_enum(method = :each, *args) ⇒ Enumerator #enum_for(method = :each, *args) ⇒ Enumerator #to_enum(method = :each, *args) {|*args| ... } ⇒ Enumerator #enum_for(method = :each, *args) {|*args| ... } ⇒ Enumerator
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).
Examples
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
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 |
# File 'enumerator.c', line 241
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;
}
|
#to_s ⇒ String
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.”
443 444 445 446 447 448 449 450 451 452 453 |
# File 'object.c', line 443
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;
}
|
#trust ⇒ Object
Deprecated method that is equivalent to #untaint.
1017 1018 1019 1020 1021 1022 |
# File 'object.c', line 1017
VALUE
rb_obj_trust(VALUE obj)
{
rb_warning("trust is deprecated and its behavior is same as untaint");
return rb_obj_untaint(obj);
}
|
#untaint ⇒ Object
Removes the tainted mark from the object.
See #taint for more information.
970 971 972 973 974 975 976 977 978 979 |
# File 'object.c', line 970
VALUE
rb_obj_untaint(VALUE obj)
{
rb_secure(3);
if (OBJ_TAINTED(obj)) {
rb_check_frozen(obj);
FL_UNSET(obj, FL_TAINT);
}
return obj;
}
|
#untrust ⇒ Object
Deprecated method that is equivalent to #taint.
1002 1003 1004 1005 1006 1007 |
# File 'object.c', line 1002
VALUE
rb_obj_untrust(VALUE obj)
{
rb_warning("untrust is deprecated and its behavior is same as taint");
return rb_obj_taint(obj);
}
|
#untrusted? ⇒ Boolean
Deprecated method that is equivalent to #tainted?.
988 989 990 991 992 993 |
# File 'object.c', line 988
VALUE
rb_obj_untrusted(VALUE obj)
{
rb_warning("untrusted? is deprecated and its behavior is same as tainted?");
return rb_obj_tainted(obj);
}
|
#validate_object ⇒ Object
:nodoc:
11103 11104 11105 11106 11107 11108 11109 11110 11111 11112 11113 11114 11115 11116 11117 11118 11119 11120 11121 11122 11123 11124 11125 11126 11127 11128 11129 11130 11131 11132 11133 11134 |
# File 'parse.y', line 11103
static VALUE
ripper_validate_object(VALUE self, VALUE x)
{
if (x == Qfalse) return x;
if (x == Qtrue) return x;
if (x == Qnil) return x;
if (x == Qundef)
rb_raise(rb_eArgError, "Qundef given");
if (FIXNUM_P(x)) return x;
if (SYMBOL_P(x)) return x;
if (!rb_is_pointer_to_heap(x))
rb_raise(rb_eArgError, "invalid pointer: %p", x);
switch (BUILTIN_TYPE(x)) {
case T_STRING:
case T_OBJECT:
case T_ARRAY:
case T_BIGNUM:
case T_FLOAT:
case T_COMPLEX:
case T_RATIONAL:
return x;
case T_NODE:
if (nd_type(x) != NODE_LASGN) {
rb_raise(rb_eArgError, "NODE given: %p", x);
}
return ((NODE *)x)->nd_rval;
default:
rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
x, rb_obj_classname(x));
}
return x;
}
|