static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
    VALUE result = rb_funcall(obj1, id_match, 1, obj2);
    return RTEST(result) ? Qfalse : Qtrue;
}

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

static VALUE
rb_obj_cmp(VALUE obj1, VALUE obj2)
{
    if (obj1 == obj2 || 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?.

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

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

static VALUE
rb_obj_match(VALUE obj1, VALUE obj2)
{
    return Qnil;
}

Сопоставление с образцом – переопределяется потомками (в частности, Regexp и String) для обеспечения осмысленной семантики сопоставления с образцом.

# File lib/csv.rb, line 2318
def CSV(*args, &block)
  CSV.instance(*args, &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

# File lib/delegate.rb, line 389
def DelegateClass(superclass)
  klass = Class.new(Delegator)
  methods = superclass.instance_methods
  methods -= ::Delegator.public_api
  methods -= [:to_s,:inspect,:=~,:!~,:===]
  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
    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.protected_instance_methods
  end
  klass.define_singleton_method :protected_instance_methods do |all=true|
    super(all) | superclass.protected_instance_methods
  end
  return klass
end

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

class MyClass < DelegateClass(ClassToDelegateTo) # 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 95
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

VALUE
rb_obj_class(VALUE obj)
{
    return rb_class_real(CLASS_OF(obj));
}

Возвращает класс объекта obj. Этот метод должен всегда вызываться с явным получателем, так как class также является зарезервированным словом в Ruby.

1.class      #=> Fixnum
self.class   #=> Object

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);
    RBASIC(clone)->flags |= RBASIC(obj)->flags & ~(FL_PROMOTED0|FL_PROMOTED1|FL_FREEZE|FL_FINALIZE);

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

Создает поверхностную копию obj — переменные экземпляра obj копируются, но не сами объекты, на которые они ссылаются. clone копирует состояние frozen и tainted объекта obj. См. также обсуждение в 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\">"

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

# File lib/rexml/xpath_parser.rb, line 10
def dclone
  clone
end

предоставляет унифицированную clone операцию для REXML::XPathParser для использования с различными типами Object.

# File lib/irb/src_encoding.rb, line 2
def default_src_encoding
  return __ENCODING__
end

НЕ ЗАПИСЫВАЙТЕ НИКАКИХ МАГИЧЕСКИХ КОММЕНТАРИЕВ ЗДЕСЬ.

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

Определяет метод-синглтон в получателе. Параметр 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!"

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

Выводит obj на указанный порт (по умолчанию $>). Эквивалентно:

def display(port=$>)
  port.write self
end

Например:

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

выводит:

1cat456

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

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

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

о dup и 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:0x401b3a38>
s2.foo #=> "foo"

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

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)

Обычно вызывается #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

%[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_obj_equal(VALUE obj1, VALUE obj2)
{
    if (obj1 == obj2) return Qtrue;
    return Qfalse;
}

Равенство — На уровне 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 для проверки равенства элементов. Для объектов класса 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);
    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. Будет возбуждено исключение RuntimeError, если попытка изменения будет предпринята. Нет способа разморозить замороженный объект. См. также Object#frozen?.

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

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

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

VALUE
rb_obj_frozen_p(VALUE obj)
{
    return OBJ_FROZEN(obj) ? Qtrue : Qfalse;
}

Возвращает статус заморозки obj.

a = [ "a", "b", "c" ]
a.freeze    #=> ["a", "b", "c"]
a.frozen?   #=> true

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
    return LONG2FIX(rb_objid_hash(index));
}

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

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

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

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);
    if (rb_obj_class(obj) == c) return Qtrue;
    return Qfalse;
}

Возвращает 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 = 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);
}

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

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

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

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

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

VALUE
rb_obj_is_kind_of(VALUE obj, VALUE c)
{
    VALUE cl = CLASS_OF(obj);

    c = class_or_module_required(c);
    return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse;
}

Возвращает 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

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

Возвращает obj.

string = 'my 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);

    c = class_or_module_required(c);
    return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : 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"

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]

static 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
     */
    if (STATIC_SYM_P(obj)) {
        return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
    }
    else if (FLONUM_P(obj)) {
#if SIZEOF_LONG == SIZEOF_VOIDP
        return LONG2NUM((SIGNED_VALUE)obj);
#else
        return LL2NUM((SIGNED_VALUE)obj);
#endif
    }
    else if (SPECIAL_CONST_P(obj)) {
        return LONG2NUM((SIGNED_VALUE)obj);
    }
    return nonspecial_obj_id(obj);
}

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

То же самое число будет возвращено при всех вызовах 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, будут отображаться только те методы, которые находятся в получателе.

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

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

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

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

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, будут отображаться только те методы, которые находятся в получателе.

VALUE
rb_f_public_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal(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 = 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;
}

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

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_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] = rb_to_symbol(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;
}

Возвращает 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(argc, argv, recv, CALL_FCALL);
}

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

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 — это Fixnum или 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)
{
    rb_method_entry_t *me;
    VALUE klass;
    ID id = rb_check_id(&vid);
    if (!id) {
        if (!NIL_P(klass = rb_singleton_class_get(obj)) &&
            respond_to_missing_p(klass, obj, vid, FALSE)) {
            id = rb_intern_str(vid);
            return mnew_missing(klass, klass, obj, id, id, rb_cMethod);
        }
        rb_name_error_str(vid, "undefined singleton method `%"PRIsVALUE"' for `%"PRIsVALUE"'",
                          QUOTE(vid), obj);
    }
    if (NIL_P(klass = rb_singleton_class_get(obj)) ||
        UNDEFINED_METHOD_ENTRY_P(me = rb_method_entry_at(klass, id)) ||
        UNDEFINED_REFINED_METHOD_P(me->def)) {
        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);
}

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

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 recur, ary, klass, origin;
    struct method_entry_arg me_arg;
    st_table *mtbl;

    if (argc == 0) {
	recur = Qtrue;
    }
    else {
	rb_scan_args(argc, argv, "01", &recur);
    }
    klass = CLASS_OF(obj);
    origin = RCLASS_ORIGIN(klass);
    me_arg.list = st_init_numtable();
    me_arg.recur = RTEST(recur);
    if (klass && FL_TEST(klass, FL_SINGLETON)) {
	if ((mtbl = RCLASS_M_TBL(origin)) != 0)
	    st_foreach(mtbl, method_entry_i, (st_data_t)&me_arg);
	klass = RCLASS_SUPER(klass);
    }
    if (RTEST(recur)) {
	while (klass && (FL_TEST(klass, FL_SINGLETON) || RB_TYPE_P(klass, T_ICLASS))) {
	    if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0)
		st_foreach(mtbl, method_entry_i, (st_data_t)&me_arg);
	    klass = RCLASS_SUPER(klass);
	}
    }
    ary = rb_ary_new();
    st_foreach(me_arg.list, ins_methods_i, ary);
    st_free_table(me_arg.list);

    return ary;
}

Возвращает массив имён методов-синглтонов для 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]

# File lib/webrick/httpservlet/cgi_runner.rb, line 11
def sysread(io, size)
  buf = ""
  while size > 0
    tmp = io.sysread(size)
    buf << tmp
    size -= tmp.bytesize
  end
  return buf
end

cgi_runner.rb – запуск программы CGI.

Автор: IPR – Программирование в Интернете с помощью Ruby – авторы Авторские права © 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU Авторские права © 2002 авторы Программирование в Интернете с помощью Ruby. Все права защищены.

$IPR: cgi_runner.rb,v 1.9 2002/09/25 11:33:15 gotoyuzo Exp $

VALUE
rb_obj_taint(VALUE obj)
{
    if (!OBJ_TAINTED(obj) && OBJ_TAINTABLE(obj)) {
        rb_check_frozen(obj);
        OBJ_TAINT(obj);
    }
    return obj;
}

Пометить объект как испорченный.

Объекты, помеченные как испорченные, будут ограничены в использовании различных встроенных методов. Это делается для предотвращения несанкционированного доступа к данным, например, аргументам командной строки или строкам, считанным из Kernel#gets, которые могут невольно нанести ущерб системе пользователя.

Чтобы проверить, является ли объект испорченным, используйте tainted?.

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

В уровне $SAFE 3 все вновь созданные объекты являются испорченными, и вы не можете размечать их как неповрежденные.

VALUE
rb_obj_tainted(VALUE obj)
{
    if (OBJ_TAINTED(obj))
        return Qtrue;
    return Qfalse;
}

Возвращает true, если объект испорчен.

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

VALUE
rb_obj_tap(VALUE obj)
{
    rb_yield(obj);
    return obj;
}

Передает self в блок, а затем возвращает self. Основное назначение этого метода — «проникнуть» в цепочку вызовов методов для выполнения операций над промежуточными результатами в этой цепочке.

(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}"}

# File lib/timeout.rb, line 123
def timeout(n, e = nil, &block)
  Timeout::timeout(n, e, &block)
end

Идентично:

Timeout::timeout(n, e, &block).

Этот метод устарел и предоставляется только для обратной совместимости. Вместо него следует использовать Timeout#timeout.

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)

Обычно #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

%[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);
    OBJ_INFECT(str, obj);

    return str;
}

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

VALUE
rb_obj_trust(VALUE obj)
{
    rb_warning("trust is deprecated and its behavior is same as untaint");
    return rb_obj_untaint(obj);
}

Устаревший метод, эквивалентный untaint.

# File lib/mathn.rb, line 40
warn('lib/mathn.rb is deprecated') if $VERBOSE

mathn

mathn служит для повышения точности математических операций в Ruby и для интеграции других стандартных математических библиотек.

Без mathn:

3 / 2 => 1 # Integer

С mathn:

3 / 2 => 3/2 # Rational

mathn сохраняет значения в точных терминах.

Без mathn:

20 / 9 * 3 * 14 / 7 * 3 / 2 # => 18

С mathn:

20 / 9 * 3 * 14 / 7 * 3 / 2 # => 20

При использовании 'mathn' также загружаются библиотеки Prime, CMath, Matrix и Vector.

Авторские права

Автор: Keiju ISHITSUKA (SHL Japan Inc.)

VALUE
rb_obj_untaint(VALUE obj)
{
    rb_secure(3);
    if (OBJ_TAINTED(obj)) {
        rb_check_frozen(obj);
        FL_UNSET(obj, FL_TAINT);
    }
    return obj;
}

Удаляет метку испорченности объекта.

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

VALUE
rb_obj_untrust(VALUE obj)
{
    rb_warning("untrust is deprecated and its behavior is same as taint");
    return rb_obj_taint(obj);
}

Устаревший метод, эквивалентный taint.

VALUE
rb_obj_untrusted(VALUE obj)
{
    rb_warning("untrusted? is deprecated and its behavior is same as tainted?");
    return rb_obj_tainted(obj);
}

Устаревший метод, эквивалентный tainted?.

# File lib/irb/xmp.rb, line 164
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 для получения дополнительной информации.