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).
First, whatâs elsewhere. Class Object:
Inherits from class BasicObject.
Includes module Kernel.
Here, class Object provides methods for:
Querying¶ ↑!~: Returns true if self does not match the given object, otherwise false.
<=>: Returns 0 if self and the given object object are the same object, or if self == object; otherwise returns nil.
===: Implements case equality, effectively the same as calling ==.
eql?: Implements hash equality, effectively the same as calling ==.
kind_of? (aliased as is_a?): Returns whether given argument is an ancestor of the singleton class of self.
instance_of?: Returns whether self is an instance of the given class.
instance_variable_defined?: Returns whether the given instance variable is defined in self.
method: Returns the Method object for the given method in self.
methods: Returns an array of symbol names of public and protected methods in self.
nil?: Returns false. (Only nil responds true to method nil?.)
object_id: Returns an integer corresponding to self that is unique for the current process
private_methods: Returns an array of the symbol names of the private methods in self.
protected_methods: Returns an array of the symbol names of the protected methods in self.
public_method: Returns the Method object for the given public method in self.
public_methods: Returns an array of the symbol names of the public methods in self.
respond_to?: Returns whether self responds to the given method.
singleton_class: Returns the singleton class of self.
singleton_method: Returns the Method object for the given singleton method in self.
singleton_methods: Returns an array of the symbol names of the singleton methods in self.
define_singleton_method: Defines a singleton method in self for the given symbol method-name and block or proc.
extend: Includes the given modules in the singleton class of self.
public_send: Calls the given public method in self with the given argument.
send: Calls the given method in self with the given argument.
instance_variable_get: Returns the value of the given instance variable in self, or nil if the instance variable is not set.
instance_variable_set: Sets the value of the given instance variable in self to the given object.
instance_variables: Returns an array of the symbol names of the instance variables in self.
remove_instance_variable: Removes the named instance variable from self.
clone: Returns a shallow copy of self, including singleton class and frozen state.
define_singleton_method: Defines a singleton method in self for the given symbol method-name and block or proc.
dup: Returns a shallow unfrozen copy of self.
enum_for (aliased as to_enum): Returns an Enumerator for self using the using the given method, arguments, and block.
extend: Includes the given modules in the singleton class of self.
freeze: Prevents further modifications to self.
hash: Returns the integer hash value for self.
inspect: Returns a human-readable string representation of self.
itself: Returns self.
method_missing: Method called when an undefined method is called on self.
public_send: Calls the given public method in self with the given argument.
send: Calls the given method in self with the given argument.
to_s: Returns a string representation of self.
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.
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 GIT commit hash for this ruby.
The running version of ruby
This writes the prism ripper translation into the Ripper constant so that users can transparently use Ripper without any changes.
Holds the original stderr
Holds the original stdin
Holds the original stdout
The Binding of the top level scope
def self.yaml_tag url Psych.add_tag(url, self) endPublic Instance Methods Source
static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
VALUE result = rb_funcall(obj1, id_match, 1, obj2);
return rb_obj_not(result);
}
Returns true if two objects do not match (using the =~ method), otherwise false.
Sourcestatic VALUE
rb_obj_cmp(VALUE obj1, VALUE obj2)
{
if (rb_equal(obj1, obj2))
return INT2FIX(0);
return Qnil;
}
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?.
#define case_equal rb_equal
Returns true or false.
Like Object#==, if object is an instance of Object (and not an instance of one of its many subclasses).
This method is commonly overridden by those subclasses, to provide meaningful semantics in case statements.
def DelegateClass(superclass, &block)
klass = Class.new(Delegator)
ignores = [*::Delegator.public_api, :to_s, :inspect, :=~, :!~, :===]
protected_instance_methods = superclass.protected_instance_methods
protected_instance_methods -= ignores
public_instance_methods = superclass.public_instance_methods
public_instance_methods -= ignores
klass.module_eval do
def __getobj__
unless defined?(@delegate_dc_obj)
return yield if block_given?
__raise__ ::ArgumentError, "not delegated"
end
@delegate_dc_obj
end
def __setobj__(obj)
__raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
@delegate_dc_obj = obj
end
protected_instance_methods.each do |method|
define_method(method, Delegator.delegating_block(method))
protected method
end
public_instance_methods.each do |method|
define_method(method, Delegator.delegating_block(method))
end
end
klass.define_singleton_method :public_instance_methods do |all=true|
super(all) | superclass.public_instance_methods
end
klass.define_singleton_method :protected_instance_methods do |all=true|
super(all) | superclass.protected_instance_methods
end
klass.define_singleton_method :instance_methods do |all=true|
super(all) | superclass.instance_methods
end
klass.define_singleton_method :public_instance_method do |name|
super(name)
rescue NameError
raise unless self.public_instance_methods.include?(name)
superclass.public_instance_method(name)
end
klass.define_singleton_method :instance_method do |name|
super(name)
rescue NameError
raise unless self.instance_methods.include?(name)
superclass.instance_method(name)
end
klass.module_eval(&block) if block
return klass
end
The primary interface to this library. Use to setup delegation when defining your class.
class MyClass < DelegateClass(ClassToDelegateTo)
def initialize
super(obj_of_ClassToDelegateTo)
end
end
or:
MyClass = DelegateClass(ClassToDelegateTo) do
def initialize
super(obj_of_ClassToDelegateTo)
end
end
Hereâs a sample of use from Tempfile which is really a File object with a few special rules about storage location and when the File should be deleted. That makes for an almost textbook perfect example of how to use delegation.
class Tempfile < DelegateClass(File)
def initialize(basename, tmpdir=Dir::tmpdir)
@tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
super(@tmpfile)
end
end
Calls superclass method
Sourcedef Digest(name)
const = name.to_sym
Digest::REQUIRE_MUTEX.synchronize {
Digest.const_missing(const)
}
rescue LoadError
if Digest.const_defined?(const)
Digest.const_get(const)
else
raise
end
end
Returns a Digest subclass by name in a thread-safe manner even when on-demand loading is involved.
require 'digest'
Digest("MD5")
Digest(:SHA256)
Digest(:Foo)
Source
static VALUE
rb_obj_define_method(int argc, VALUE *argv, VALUE obj)
{
VALUE klass = rb_singleton_class(obj);
const rb_scope_visibility_t scope_visi = {METHOD_VISI_PUBLIC, FALSE};
return rb_mod_define_method_with_visibility(argc, argv, klass, &scope_visi);
}
Defines a public 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. If a block or a method has parameters, theyâre used as method parameters.
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
guy = "Bob"
guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
guy.hello
chris = "Chris"
chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" }
chris.greet("Hi")
Source
static VALUE
rb_obj_display(int argc, VALUE *argv, VALUE self)
{
VALUE out;
out = (!rb_check_arity(argc, 0, 1) ? rb_ractor_stdout() : argv[0]);
rb_io_write(out, self);
return Qnil;
}
Writes self on the given port:
1.display "cat".display [ 4, 5, 6 ].display puts
Output:
1cat[4, 5, 6]Source
VALUE
rb_obj_dup(VALUE obj)
{
VALUE dup;
if (special_object_p(obj)) {
return obj;
}
dup = rb_obj_alloc(rb_obj_class(obj));
return rb_obj_dup_setup(obj, dup);
}
Produces a shallow copy of objâthe instance variables of obj are copied, but not the objects they reference.
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 s1.extend(Foo) s1.foo s2 = s1.clone s2.foo s3 = s1.dup s3.foo
Creates a new Enumerator which will enumerate by calling method on obj, passing args if any. What was yielded by method becomes values of enumerator.
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 }
a = [1, 2, 3]
some_method(a.to_enum)
very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first
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
def repeat(n)
raise ArgumentError, "#{n} is negative!" if n < 0
unless block_given?
return to_enum(__method__, n) do
sz = size
sz * n if sz
end
end
each do |*val|
n.times { yield *val }
end
end
end
%i[hello world].repeat(2) { |w| puts w }
enum = (1..14).repeat(3)
enum.first(4)
enum.size
Source
VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
return RBOOL(obj1 == obj2);
}
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 obj.equal? other obj.equal? obj
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 any pair of objects where eql? returns true, the hash value of both objects must be equal. So any subclass that overrides eql? should also override hash appropriately.
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 1.eql? 1.0Source
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);
if (FL_TEST(argv[i], RMODULE_IS_REFINEMENT)) {
rb_raise(rb_eTypeError, "Cannot extend object with refinement");
}
}
while (argc--) {
rb_funcall(argv[argc], id_extend_object, 1, obj);
rb_funcall(argv[argc], id_extended, 1, obj);
}
return obj;
}
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
k.extend(Mod)
k.hello
Source
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;
}
Prevents further modifications to obj. A FrozenError 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_hash(VALUE obj)
{
long hnum = any_hash(obj, objid_hash);
return ST2FIX(hnum);
}
Generates an Integer 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 an Integer 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.
Certain core classes such as Integer use built-in hash calculations and do not call the hash method when used as a hash key.
When implementing your own hash based on multiple values, the best practice is to combine the class and any values using the hash code of an array:
For example:
def hash [self.class, a, b, c].hash end
The reason for this is that the Array#hash method already has logic for safely and efficiently combining multiple hash values.
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 a string containing a human-readable representation of obj. The default inspect shows the objectâs class name, an encoding of its memory address, 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
Time.new.inspect
class Foo
end
Foo.new.inspect
class Bar
def initialize
@bar = 1
end
end
Bar.new.inspect
Source
VALUE
rb_obj_is_instance_of(VALUE obj, VALUE c)
{
c = class_or_module_required(c);
return RBOOL(rb_obj_class(obj) == c);
}
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 b.instance_of? B b.instance_of? CSource
static VALUE
rb_obj_ivar_defined(VALUE obj, VALUE iv)
{
ID id = id_for_var(obj, iv, instance);
if (!id) {
return Qfalse;
}
return rb_ivar_defined(obj, id);
}
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)
fred.instance_variable_defined?("@b")
fred.instance_variable_defined?("@c")
Source
static VALUE
rb_obj_ivar_get(VALUE obj, VALUE iv)
{
ID id = id_for_var(obj, iv, instance);
if (!id) {
return Qnil;
}
return rb_ivar_get(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)
fred.instance_variable_get("@b")
Source
static VALUE
rb_obj_ivar_set_m(VALUE obj, VALUE iv, VALUE val)
{
ID id = id_for_var(obj, iv, instance);
if (!id) id = rb_intern_str(iv);
return rb_ivar_set(obj, id, val);
}
Sets the instance variable named by symbol to the given object. This may circumvent the encapsulation intended by the author of the class, so it should be used with care. 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')
fred.instance_variable_set(:@c, 'cat')
fred.inspect
Source
VALUE
rb_obj_instance_variables(VALUE obj)
{
VALUE ary;
ary = rb_ary_new();
rb_ivar_foreach(obj, ivar_i, ary);
return ary;
}
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
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 b.is_a? B b.is_a? C b.is_a? M b.kind_of? A b.kind_of? B b.kind_of? C b.kind_of? MSource
static VALUE
rb_obj_itself(VALUE obj)
{
return obj;
}
Returns the receiver.
string = "my string" string.itself.object_id == string.object_idSource
VALUE
rb_obj_is_kind_of(VALUE obj, VALUE c)
{
VALUE cl = CLASS_OF(obj);
RUBY_ASSERT(RB_TYPE_P(cl, T_CLASS));
// Fastest path: If the object's class is an exact match we know `c` is a
// class without checking type and can return immediately.
if (cl == c) return Qtrue;
// Note: YJIT needs this function to never allocate and never raise when
// `c` is a class or a module.
if (LIKELY(RB_TYPE_P(c, T_CLASS))) {
// Fast path: Both are T_CLASS
return class_search_class_ancestor(cl, c);
}
else if (RB_TYPE_P(c, T_ICLASS)) {
// First check if we inherit the includer
// If we do we can return true immediately
VALUE includer = RCLASS_INCLUDER(c);
if (cl == includer) return Qtrue;
// Usually includer is a T_CLASS here, except when including into an
// already included Module.
// If it is a class, attempt the fast class-to-class check and return
// true if there is a match.
if (RB_TYPE_P(includer, T_CLASS) && class_search_class_ancestor(cl, includer))
return Qtrue;
// We don't include the ICLASS directly, so must check if we inherit
// the module via another include
return RBOOL(class_search_ancestor(cl, RCLASS_ORIGIN(c)));
}
else if (RB_TYPE_P(c, T_MODULE)) {
// Slow path: check each ancestor in the linked list and its method table
return RBOOL(class_search_ancestor(cl, RCLASS_ORIGIN(c)));
}
else {
rb_raise(rb_eTypeError, "class or module required");
UNREACHABLE_RETURN(Qfalse);
}
}
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 b.is_a? B b.is_a? C b.is_a? M b.kind_of? A b.kind_of? B b.kind_of? C b.kind_of? MSource
VALUE
rb_obj_method(VALUE obj, VALUE vid)
{
return obj_method(obj, vid, FALSE);
}
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
l = Demo.new('Fred')
m = l.method("hello")
m.call
Note that Method implements to_proc method, which means it can be used with iterators.
[ 1, 2, 3 ].each(&method(:puts))
out = File.open('test.txt', 'w')
[ 1, 2, 3 ].each(&out.method(:puts))
require 'date'
%w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
Source
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);
}
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â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]
k.methods.length
k.methods(false)
def k.singleton_method; end
k.methods(false)
module M123; def m123; end end
k.extend M123
k.methods(false)
Source
VALUE
rb_false(VALUE obj)
{
return Qfalse;
}
Only the object nil responds true to nil?.
Object.new.nil? nil.nil?Source
VALUE
rb_obj_id(VALUE obj)
{
/* If obj is an immediate, the object ID is obj directly converted to a Numeric.
* Otherwise, the object ID is a Numeric that is a non-zero multiple of
* (RUBY_IMMEDIATE_MASK + 1) which guarantees that it does not collide with
* any immediates. */
return rb_find_object_id(rb_gc_get_objspace(), obj, rb_gc_impl_object_id);
}
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.
BasicObject implements __id__, Kernel implements object_id.
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 (21 * 2).object_id == (21 * 2).object_id "hello".object_id == "hello".object_id "hi".freeze.object_id == "hi".freeze.object_idSource
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 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_protected_methods(int argc, const VALUE *argv, VALUE obj)
{
return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_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_public_method(VALUE obj, VALUE vid)
{
return obj_method(obj, vid, TRUE);
}
Similar to method, searches public method only.
SourceVALUE
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);
}
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.
static VALUE
rb_f_public_send(int argc, VALUE *argv, VALUE recv)
{
return send_internal_kw(argc, argv, recv, CALL_PUBLIC);
}
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")Source
VALUE
rb_obj_remove_instance_variable(VALUE obj, VALUE name)
{
const ID id = id_for_var(obj, name, an, instance);
// Frozen check comes here because it's expected that we raise a
// NameError (from the id_for_var check) before we raise a FrozenError
rb_check_frozen(obj);
if (id) {
VALUE val = rb_ivar_delete(obj, id, Qundef);
if (!UNDEF_P(val)) return val;
}
rb_name_err_raise("instance variable %1$s not defined",
obj, name);
UNREACHABLE_RETURN(Qnil);
}
Removes the named instance variable from obj, returning that variableâs value. The name can be passed as a symbol or as a string.
class Dummy
attr_reader :var
def initialize
@var = 99
end
def remove
remove_instance_variable(:@var)
end
end
d = Dummy.new
d.var
d.remove
d.var
Source
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 (UNDEF_P(ret)) ret = Qfalse;
return ret;
}
return RBOOL(basic_obj_respond_to(ec, obj, id, !RTEST(priv)));
}
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.
Sourcestatic VALUE
obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
{
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.
VALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
return send_internal_kw(argc, argv, recv, CALL_FCALL);
}
Invokes the method identified by symbol, passing it any arguments specified. When the method is identified by a string, the string is converted to a symbol.
BasicObject implements __send__, Kernel implements send. __send__ is safer than send when obj has the same method name like Socket. See also public_send.
class Klass
def hello(*args)
"Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers"
Source
static VALUE
rb_obj_singleton_class(VALUE obj)
{
return rb_singleton_class(obj);
}
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 String.singleton_class nil.singleton_classSource
VALUE
rb_obj_singleton_method(VALUE obj, VALUE vid)
{
VALUE sc = rb_singleton_class_get(obj);
VALUE klass;
ID id = rb_check_id(&vid);
if (NIL_P(sc) ||
NIL_P(klass = RCLASS_ORIGIN(sc)) ||
!NIL_P(rb_special_singleton_class(obj))) {
/* goto undef; */
}
else if (! id) {
VALUE m = mnew_missing_by_name(klass, obj, &vid, FALSE, rb_cMethod);
if (m) return m;
/* else goto undef; */
}
else {
VALUE args[2] = {obj, vid};
VALUE ruby_method = rb_rescue(rb_obj_singleton_method_lookup, (VALUE)args, rb_obj_singleton_method_lookup_fail, Qfalse);
if (ruby_method) {
struct METHOD *method = (struct METHOD *)RTYPEDDATA_GET_DATA(ruby_method);
VALUE lookup_class = RBASIC_CLASS(obj);
VALUE stop_class = rb_class_superclass(sc);
VALUE method_class = method->iclass;
/* Determine if method is in singleton class, or module included in or prepended to it */
do {
if (lookup_class == method_class) {
return ruby_method;
}
lookup_class = RCLASS_SUPER(lookup_class);
} while (lookup_class && lookup_class != stop_class);
}
}
/* undef: */
vid = ID2SYM(id);
rb_name_err_raise("undefined singleton method '%1$s' for '%2$s'",
obj, vid);
UNREACHABLE_RETURN(Qundef);
}
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
m = k.singleton_method(:hello)
Source
VALUE
rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj)
{
VALUE ary, klass, origin;
struct method_entry_arg me_arg;
struct rb_id_table *mtbl;
int recur = TRUE;
if (rb_check_arity(argc, 0, 1)) recur = RTEST(argv[0]);
if (RCLASS_SINGLETON_P(obj)) {
rb_singleton_class(obj);
}
klass = CLASS_OF(obj);
origin = RCLASS_ORIGIN(klass);
me_arg.list = st_init_numtable();
me_arg.recur = recur;
if (klass && RCLASS_SINGLETON_P(klass)) {
if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
klass = RCLASS_SUPER(klass);
}
if (recur) {
while (klass && (RCLASS_SINGLETON_P(klass) || 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_new2(me_arg.list->num_entries);
st_foreach(me_arg.list, ins_methods_i, ary);
st_free_table(me_arg.list);
return ary;
}
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 a.singleton_methods(false) a.singleton_methodsSource
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()) {
RB_OBJ_WRITE(enumerator, &enumerator_ptr(enumerator)->size, rb_block_proc());
}
return enumerator;
}
Creates a new Enumerator which will enumerate by calling method on obj, passing args if any. What was yielded by method becomes values of enumerator.
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 }
a = [1, 2, 3]
some_method(a.to_enum)
very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first
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
def repeat(n)
raise ArgumentError, "#{n} is negative!" if n < 0
unless block_given?
return to_enum(__method__, n) do
sz = size
sz * n if sz
end
end
each do |*val|
n.times { yield *val }
end
end
end
%i[hello world].repeat(2) { |w| puts w }
enum = (1..14).repeat(3)
enum.first(4)
enum.size
Source
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);
return str;
}
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â.
def to_yaml options = {}
Psych.dump self, options
end
Convert an object to YAML. See Psych.dump for more information on the available options.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4