класс Object

static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
    VALUE result = rb_funcall(obj1, id_match, 1, obj2);
    return rb_obj_not(result);
}

Возвращает true, если два объекта не совпадают (используя метод =~), иначе false.

static VALUE
rb_obj_cmp(VALUE obj1, VALUE obj2)
{
    if (rb_equal(obj1, obj2))
        return INT2FIX(0);
    return Qnil;
}

Возвращает 0, если obj и other это один и тот же объект или obj == other, иначе nil.

Метод <=> используется различными методами для сравнения объектов, например Enumerable#sort, Enumerable#max и т.д.

Ваша реализация <=> должна возвращать одно из следующих значений: -1, 0, 1 или nil. -1 означает, что self меньше, чем other. 0 означает, что self равен other. 1 означает, что self больше, чем other. Nil означает, что два значения не могут быть сравнены.

При определении <=>, вы можете включить Comparable, чтобы получить методы <=, <, ==, >=, > и between?.

#define case_equal rb_equal

Равенство по регистру – Для класса Object, фактически то же самое, что и вызов #==, но обычно переопределяется потомками для предоставления осмысленной семантики в case операторах.

# File lib/csv.rb, line 2875
def CSV(*args, **options, &block)
  CSV.instance(*args, **options, &block)
end

Передает args в CSV::instance.

CSV("CSV,data").read
  #=> [["CSV", "data"]]

Если указан блок, экземпляру передается блок, и возвращаемое значение становится возвращаемым значением блока.

CSV("CSV,data") { |c|
  c.read.any? { |a| a.include?("data") }
} #=> true

CSV("CSV,data") { |c|
  c.read.any? { |a| a.include?("zombies") }
} #=> false

CSV параметры также могут быть указаны.

io = StringIO.new
CSV(io, col_sep: ";") { |csv| csv << ["a", "b", "c"] }

Этот API не является безопасным для Ractor.

# File lib/delegate.rb, line 394
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__ # :nodoc:
      unless defined?(@delegate_dc_obj)
        return yield if block_given?
        __raise__ ::ArgumentError, "not delegated"
      end
      @delegate_dc_obj
    end
    def __setobj__(obj)  # :nodoc:
      __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

Основной интерфейс этой библиотеки. Используйте для настройки делегирования при определении вашего класса.

class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

или:

MyClass = DelegateClass(ClassToDelegateTo) do    # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

Вот пример использования из Tempfile, который на самом деле является объектом File с несколькими специальными правилами о местоположении хранения и о том, когда File должен быть удален. Это делает его почти идеальным примером того, как использовать делегирование.

class Tempfile < DelegateClass(File)
  # constant and class member data initialization...

  def initialize(basename, tmpdir=Dir::tmpdir)
    # build up file path/name in var tmpname...

    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)

    # ...

    super(@tmpfile)

    # below this point, all methods of File are supported...
  end

  # ...
end

# File ext/digest/lib/digest.rb, line 110
def Digest(name)
  const = name.to_sym
  Digest::REQUIRE_MUTEX.synchronize {
    # Ignore autoload's because it is void when we have #const_missing
    Digest.const_missing(const)
  }
rescue LoadError
  # Constants do not necessarily rely on digest/*.
  if Digest.const_defined?(const)
    Digest.const_get(const)
  else
    raise
  end
end

Возвращает подкласс Digest путем name потокобезопасным образом, даже когда используется загрузка по требованию.

require 'digest'

Digest("MD5")
# => Digest::MD5

Digest(:SHA256)
# => Digest::SHA256

Digest(:Foo)
# => LoadError: library not found for class Digest::Foo -- digest/foo

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);
}

Определяет публичный одиночный метод в получателе. Параметр method может быть Proc, Method или UnboundMethod объектом. Если указан блок, он используется в качестве тела метода. Если блок или метод имеет параметры, они используются в качестве параметров метода.

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!"

chris = "Chris"
chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" }
chris.greet("Hi") #=> "Hi, I'm Chris!"

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;
}

Записывает self в указанный порт:

1.display
"cat".display
[ 4, 5, 6 ].display
puts

Вывод:

1cat[4, 5, 6]

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;
}

Создает неглубокую копию obj—переменные экземпляра obj копируются, но не объекты, на которые они ссылаются.

Этот метод может иметь специфичное для класса поведение. Если это так, то это поведение будет задокументировано в методе #initialize_copy класса.

on dup vs clone

В общем, clone и dup могут иметь различную семантику в дочерних классах. В то время как clone используется для дублирования объекта, включая его внутреннее состояние, dup обычно использует класс дочернего объекта для создания нового экземпляра.

При использовании dup, любые модули, с которыми был расширен объект, не будут скопированы.

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:0x401be280>
s2.foo #=> "foo"

s3 = s1.dup #=> #<Klass:0x401c1084>
s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084>

MJIT_FUNC_EXPORTED VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
    return RBOOL(obj1 == obj2);
}

Равенство — На уровне Object, == возвращает true, только если obj и other это один и тот же объект. Как правило, этот метод переопределяется в дочерних классах для предоставления специфичного для класса значения.

В отличие от ==, метод equal? никогда не должен переопределяться подклассами, поскольку он используется для определения идентичности объекта (то есть, a.equal?(b), если и только если a является тем же объектом, что и b):

obj = "a"
other = obj.dup

obj == other      #=> true
obj.equal? other  #=> false
obj.equal? obj    #=> true

Метод eql? возвращает true, если obj и other ссылаются на один и тот же ключ хеша. Это используется Hash для проверки членов на равенство. Для любой пары объектов, где eql? возвращает true, значение hash обоих объектов должно быть равным. Таким образом, любой подкласс, который переопределяет eql?, должен также соответствующим образом переопределять hash.

Для объектов класса Object, eql? синонимичен ==. Подклассы обычно продолжают эту традицию, создавая псевдоним eql? для их переопределенного метода ==, но есть исключения. Типы Numeric, например, выполняют преобразование типов в ==, но не в eql?, поэтому:

1 == 1.0     #=> true
1.eql? 1.0   #=> false

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;
}

Добавляет к obj методы экземпляров из каждого модуля, переданного в качестве параметра.

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"

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;
}

Запрещает дальнейшие изменения obj. Будет возбуждено исключение FrozenError, если попытка изменения будет предпринята. Разморозить замороженный объект нельзя. См. также Object#frozen?.

Этот метод возвращает self.

a = [ "a", "b", "c" ]
a.freeze
a << "z"

результат:

prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
 from prog.rb:3

Объекты следующих классов всегда заморожены: Integer, Float, Symbol.

VALUE
rb_obj_hash(VALUE obj)
{
    long hnum = any_hash(obj, objid_hash);
    return ST2FIX(hnum);
}

Генерирует значение хэша Integer для этого объекта. Эта функция должна обладать свойством, что a.eql?(b) подразумевает a.hash == b.hash.

Значение хэша используется вместе с eql? классом Hash для определения, ссылаются ли два объекта на один и тот же ключ хэша. Любое значение хэша, превышающее емкость Integer, будет усечено перед использованием.

Значение хэша для объекта может не совпадать при разных вызовах или реализациях Ruby. Если вам нужен стабильный идентификатор в разных вызовах и реализациях Ruby, вам необходимо сгенерировать его с помощью пользовательского метода.

Некоторые основные классы, такие как Integer, используют встроенные вычисления хэша и не вызывают метод hash при использовании в качестве ключа хэша.

При реализации собственного метода hash на основе нескольких значений, лучшей практикой является объединение класса и значений с использованием хэш-кода массива:

Например:

def hash
  [self.class, a, b, c].hash
end

Причина этого в том, что метод Array#hash уже имеет логику для безопасного и эффективного объединения нескольких значений хэша.

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);
    }
}

Возвращает строку, содержащую удобочитаемое представление obj. По умолчанию inspect отображает имя класса объекта, кодировку его адреса в памяти и список переменных экземпляра и их значений (вызывая inspect для каждого из них). Пользовательские классы должны переопределять этот метод для предоставления лучшего представления obj. При переопределении этого метода необходимо вернуть строку, кодировка которой совместима с кодировкой внешнего кодирования по умолчанию.

[ 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>"

VALUE
rb_obj_is_instance_of(VALUE obj, VALUE c)
{
    c = class_or_module_required(c);
    return RBOOL(rb_obj_class(obj) == c);
}

Возвращает true если obj является экземпляром заданного класса. См. также 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

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);
}

Возвращает true если заданная переменная экземпляра определена в obj. Аргументы String преобразуются в символы.

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_get(VALUE obj, VALUE iv)
{
    ID id = id_for_var(obj, iv, instance);

    if (!id) {
        return Qnil;
    }
    return rb_ivar_get(obj, id);
}

Возвращает значение заданной переменной экземпляра или nil, если переменная экземпляра не задана. Часть имени переменной @ должна быть включена для обычных переменных экземпляра. Выбрасывает исключение NameError, если переданный символ не является допустимым именем переменной экземпляра. Аргументы String преобразуются в символы.

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_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);
}

Устанавливает переменную экземпляра, названную 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\">"

VALUE
rb_obj_instance_variables(VALUE obj)
{
    VALUE ary;

    ary = rb_ary_new();
    rb_ivar_foreach(obj, ivar_i, ary);
    return ary;
}

Возвращает массив имён переменных экземпляра для получателя. Обратите внимание, что простое определение аксессора не создаёт соответствующую переменную экземпляра.

class Fred
  attr_accessor :a1
  def initialize
    @iv = 3
  end
end
Fred.new.instance_variables   #=> [:@iv]

static VALUE
rb_obj_itself(VALUE obj)
{
    return obj;
}

Возвращает получатель.

string = "my string"
string.itself.object_id == string.object_id   #=> true

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);
    }
}

Возвращает true если class является классом obj или если class является одним из суперклассов obj или модулей, включённых в 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_method(VALUE obj, VALUE vid)
{
    return obj_method(obj, vid, FALSE);
}

Ищет метод с заданным именем как получателя в obj, возвращая объект Method (или возбуждая NameError). Объект Method действует как замыкание в экземпляре объекта obj, поэтому переменные экземпляра и значение self остаются доступными.

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"

Обратите внимание, что Method реализует метод to_proc, что означает, что он может использоваться с итераторами.

[ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout

out = File.open('test.txt', 'w')
[ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file

require 'date'
%w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
#=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]

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);
}

Возвращает список имён публичных и защищённых методов obj. Это будет включать все методы, доступные в предках obj. Если необязательный параметр равен false, возвращает массив публичных и защищённых одиночных методов obj, массив не будет включать методы из модулей, включённых в 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]

MJIT_FUNC_EXPORTED VALUE
rb_false(VALUE obj)
{
    return Qfalse;
}

Только объект nil отвечает true на nil?.

Object.new.nil?   #=> false
nil.nil?          #=> 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
     */

    return rb_find_object_id(obj, cached_object_id);
}

Возвращает целочисленный идентификатор для obj.

То же самое число будет возвращено при всех вызовах object_id для данного объекта, и любые два активных объекта не будут иметь одинаковый идентификатор.

Примечание: некоторые объекты встроенных классов повторно используются для оптимизации. Это относится к непосредственным значениям и замороженным строковым литералам.

BasicObject реализует __id__, Kernel реализует object_id.

Непосредственные значения не передаются по ссылке, а передаются по значению: nil, true, false, Fixnums, Symbols и некоторые 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_private_methods(int argc, const VALUE *argv, VALUE obj)
{
    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i);
}

Возвращает список закрытых методов, доступных для obj. Если параметр all установлен в false, будут перечислены только те методы, которые находятся в получателе.

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);
}

Возвращает список защищенных методов, доступных для obj. Если параметр all установлен в false, будут перечислены только те методы, которые находятся в получателе.

VALUE
rb_obj_public_method(VALUE obj, VALUE vid)
{
    return obj_method(obj, vid, TRUE);
}

Аналогично method, но ищет только публичные методы.

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);
}

Возвращает список публичных методов, доступных для obj. Если параметр all установлен в false, будут перечислены только те методы, которые находятся в получателе.

static VALUE
rb_f_public_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal_kw(argc, argv, recv, CALL_PUBLIC);
}

Вызывает метод, идентифицированный символом, передавая ему указанные аргументы. В отличие от send, public_send вызывает только публичные методы. При идентификации метода с помощью строки, строка преобразуется в символ.

1.public_send(:puts, "hello")  # causes NoMethodError

VALUE
rb_obj_remove_instance_variable(VALUE obj, VALUE name)
{
    VALUE val = Qundef;
    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) {
        goto not_defined;
    }

    rb_shape_t * shape = rb_shape_get_shape(obj);

    switch (BUILTIN_TYPE(obj)) {
      case T_CLASS:
      case T_MODULE:
        IVAR_ACCESSOR_SHOULD_BE_MAIN_RACTOR(id);
        rb_shape_transition_shape_remove_ivar(obj, id, shape, &val);
        break;
      case T_OBJECT: {
        if (rb_shape_obj_too_complex(obj)) {
            if (rb_id_table_lookup(ROBJECT_IV_HASH(obj), id, &val)) {
                rb_id_table_delete(ROBJECT_IV_HASH(obj), id);
            }
        }
        else {
            rb_shape_transition_shape_remove_ivar(obj, id, shape, &val);
        }
        break;
      }
      default: {
        rb_shape_transition_shape_remove_ivar(obj, id, shape, &val);
        break;
      }
    }

    if (val != Qundef) {
        return val;
    }

  not_defined:
    rb_name_err_raise("instance variable %1$s not defined",
                      obj, name);
    UNREACHABLE_RETURN(Qnil);
}

Удаляет именованную переменную экземпляра из obj, возвращая значение этой переменной. Аргументы типа String преобразуются в символы.

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

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)));
}

Возвращает true, если obj отвечает на данный метод. Закрытые и защищенные методы включаются в поиск только в том случае, если необязательный второй параметр равен true.

Если метод не реализован, как Process.fork в Windows, File.lchmod в GNU/Linux и т.д., возвращается false.

Если метод не определен, вызывается метод respond_to_missing? и возвращается результат.

Если имя метода задано как строка, строка преобразуется в символ.

static VALUE
obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
{
    return Qfalse;
}

НЕ ИСПОЛЬЗОВАТЬ НЕПОСРЕДСТВЕННО.

Метод обработки, возвращающий, может ли obj отвечать на метод id или нет.

Когда имя метода задано как строка, строка преобразуется в символ.

См. respond_to? и пример для BasicObject.

VALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal_kw(argc, argv, recv, CALL_FCALL);
}

Вызывает метод, идентифицированный символом, передавая ему указанные аргументы. При идентификации метода с помощью строки, строка преобразуется в символ.

BasicObject реализует __send__, Kernel реализует send. __send__ безопаснее, чем send когда у obj есть одноимённый метод, как Socket. См. также public_send.

class Klass
  def hello(*args)
    "Hello " + args.join(' ')
  end
end
k = Klass.new
k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"

static VALUE
rb_obj_singleton_class(VALUE obj)
{
    return rb_singleton_class(obj);
}

Возвращает синглтон-класс obj. Этот метод создаёт новый синглтон-класс, если у obj его нет.

Если obj это nil, true, или false, он возвращает NilClass, TrueClass, или FalseClass соответственно. Если obj является Integer, Float или Symbol, выводится исключение TypeError.

Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class      #=> #<Class:String>
nil.singleton_class         #=> NilClass

VALUE
rb_obj_singleton_method(VALUE obj, VALUE vid)
{
    VALUE klass = rb_singleton_class_get(obj);
    ID id = rb_check_id(&vid);

    if (NIL_P(klass)) {
        /* goto undef; */
    }
    else if (NIL_P(klass = RCLASS_ORIGIN(klass))) {
        /* 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 {
        const rb_method_entry_t *me = rb_method_entry_at(klass, id);
        vid = ID2SYM(id);

        if (UNDEFINED_METHOD_ENTRY_P(me)) {
            /* goto undef; */
        }
        else if (UNDEFINED_REFINED_METHOD_P(me->def)) {
            /* goto undef; */
        }
        else {
            return mnew_from_me(me, klass, klass, obj, id, rb_cMethod, FALSE);
        }
    }

  /* undef: */
    rb_name_err_raise("undefined singleton method `%1$s' for `%2$s'",
                      obj, vid);
    UNREACHABLE_RETURN(Qundef);
}

Аналогично method, но ищет только синглтон-методы.

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_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 (RB_TYPE_P(obj, T_CLASS) && FL_TEST(obj, FL_SINGLETON)) {
        rb_singleton_class(obj);
    }
    klass = CLASS_OF(obj);
    origin = RCLASS_ORIGIN(klass);
    me_arg.list = st_init_numtable();
    me_arg.recur = 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 (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_new2(me_arg.list->num_entries);
    st_foreach(me_arg.list, ins_methods_i, ary);
    st_free_table(me_arg.list);

    return ary;
}

Возвращает массив имён синглтон-методов для obj. Если необязательный параметр all равен true, список будет включать методы в модулях, включённых в obj. Возвращаются только публичные и защищённые синглтон-методы.

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]

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;
}

Создает новый Enumerator, который будет перечислять, вызывая method у obj, передавая args при необходимости. Значения, возвращаемые методом, станут значениями перечислителя.

Если задан блок, он будет использован для расчета размера перечислителя без необходимости итерации (см. 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)

# String#split in block form is more memory-effective:
very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
# This could be rewritten more idiomatically with to_enum:
very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first

Обычно to_enum вызывается при определении методов для универсального Enumerable, если не передан блок.

Вот пример с передачей параметров и блоком расчета размера:

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

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;
}

Возвращает строку, представляющую obj. По умолчанию to_s выводит класс объекта и кодировку идентификатора объекта. В качестве специального случая, верхнеуровневый объект, который является начальной средой выполнения программ Ruby, возвращает «main».

# File ext/psych/lib/psych/core_ext.rb, line 12
def to_yaml options = {}
  Psych.dump self, options
end

Преобразует объект в YAML. См. Psych.dump для получения более подробной информации о доступных options.

# File lib/irb/xmp.rb, line 165
def xmp(exps, bind = nil)
  bind = IRB::Frame.top(1) unless bind
  xmp = XMP.new(bind)
  xmp.puts exps
  xmp
end

Удобный метод, доступный только при подключении стандартной библиотеки IRB::XMP.

Создает новый XMP объект, используя заданные выражения в качестве параметра exps, и необязательную привязку как bind, или использует верхнеуровневую привязку. Затем вычисляет заданные выражения в режиме :XMP ввода.

Например:

require 'irb/xmp'
ctx = binding
xmp 'foo = "bar"', ctx
#=> foo = "bar"
  #==>"bar"
ctx.eval 'foo'
#=> "bar"

См. XMP.new для получения дополнительной информации.