In Files

  • object.c

Class

Classes in Ruby are first-class objects—each is an instance of class Class.

When a new class is created (typically using class Name ... end), an object of type Class is created and assigned to a global constant (Name in this case). When Name.new is called to create a new object, the new method in Class is run by default. This can be demonstrated by overriding new in Class:

class Class
   alias oldNew  new
   def new(*args)
     print "Creating a new ", self.name, "\n"
     oldNew(*args)
   end
 end

 class Name
 end

 n = Name.new

produces:

Creating a new Name

Classes, modules, and objects are interrelated. In the diagram that follows, the vertical arrows represent inheritance, and the parentheses meta-classes. All metaclasses are instances of the class `Class'.

                          +-----------------+
                         |                  |
        BasicObject-->(BasicObject)         |
             ^           ^                  |
             |           |                  |
           Object---->(Object)              |
            ^  ^        ^  ^                |
            |  |        |  |                |
            |  |  +-----+  +---------+      |
            |  |  |                  |      |
            |  +-----------+         |      |
            |     |        |         |      |
     +------+     |     Module--->(Module)  |
     |            |        ^         ^      |
OtherClass-->(OtherClass)  |         |      |
                           |         |      |
                         Class---->(Class)  |
                           ^                |
                           |                |
                           +----------------+

Public Class Methods

new(super_class=Object) => a_class click to toggle source

Creates a new anonymous (unnamed) class with the given superclass (or Object if no parameter is given). You can give a class a name by assigning the class object to a constant.

 
               static VALUE
rb_class_initialize(int argc, VALUE *argv, VALUE klass)
{
    VALUE super;

    if (RCLASS_SUPER(klass) != 0) {
        rb_raise(rb_eTypeError, "already initialized class");
    }
    if (argc == 0) {
        super = rb_cObject;
    }
    else {
        rb_scan_args(argc, argv, "01", &super);
        rb_check_inheritable(super);
    }
    RCLASS_SUPER(klass) = super;
    rb_make_metaclass(klass, RBASIC(super)->klass);
    rb_class_inherited(super, klass);
    rb_mod_initialize(klass);

    return klass;
}

Public Instance Methods

allocate() => obj click to toggle source

Allocates space for a new object of class's class and does not call initialize on the new instance. The returned object must be an instance of class.

klass = Class.new do
  def initialize(*args)
    @initialized = true
  end

  def initialized?
    @initialized || false
  end
end

klass.allocate.initialized? #=> false

 
               VALUE
rb_obj_alloc(VALUE klass)
{
    VALUE obj;

    if (RCLASS_SUPER(klass) == 0 && klass != rb_cBasicObject) {
        rb_raise(rb_eTypeError, "can't instantiate uninitialized class");
    }
    if (FL_TEST(klass, FL_SINGLETON)) {
        rb_raise(rb_eTypeError, "can't create instance of singleton class");
    }
    obj = rb_funcall(klass, ID_ALLOCATOR, 0, 0);
    if (rb_obj_class(obj) != rb_class_real(klass)) {
        rb_raise(rb_eTypeError, "wrong instance allocation");
    }
    return obj;
}
new(args, ...) => obj click to toggle source

Calls allocate to create a new object of class's class, then invokes that object's initialize method, passing it args. This is the method that ends up getting called whenever an object is constructed using .new.

 
               VALUE
rb_class_new_instance(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj;

    obj = rb_obj_alloc(klass);
    rb_obj_call_init(obj, argc, argv);

    return obj;
}
superclass → a_super_class or nil click to toggle source

Returns the superclass of class, or nil.

File.superclass          #=> IO
IO.superclass            #=> Object
Object.superclass        #=> BasicObject
class Foo; end
class Bar < Foo; end
Bar.superclass           #=> Foo

returns nil when the given class hasn't a parent class:

BasicObject.superclass   #=> nil

 
               static VALUE
rb_class_superclass(VALUE klass)
{
    VALUE super = RCLASS_SUPER(klass);

    if (!super) {
        if (klass == rb_cBasicObject) return Qnil;
        rb_raise(rb_eTypeError, "uninitialized class");
    }
    while (TYPE(super) == T_ICLASS) {
        super = RCLASS_SUPER(super);
    }
    if (!super) {
        return Qnil;
    }
    return super;
}

Private Instance Methods

inherited(subclass) click to toggle source

Callback invoked whenever a subclass of the current class is created.

Example:

class Foo
   def self.inherited(subclass)
      puts "New subclass: #{subclass}"
   end
end

class Bar < Foo
end

class Baz < Bar
end

produces:

New subclass: Bar
New subclass: Baz

 
               static VALUE
rb_obj_dummy(void)
{
    return Qnil;
}