class Class

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

Typically, you create a new class by using:

class Name
 # some code describing the class behavior
end

When a new class is created, an object of type Class is initialized 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 old_new new
  def new(*args)
    print "Creating a new ", self.name, "\n"
    old_new(*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 metaclasses. All metaclasses are instances of the class ‘Class’.

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

Public Class Methods

new(super_class=Object) → a_class

new(super_class=Object) { |mod| ... } → a_class

(?Class superclass) ?{ (Class newclass) [self: Class] → void } → void

Source

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

    // an uninitialized class is still somebody's, and this writes its superclass
    rb_class_modify_check(klass);
    if (RCLASS_SUPER(klass) != 0 || klass == rb_cBasicObject) {
        rb_raise(rb_eTypeError, "already initialized class");
    }
    if (rb_check_arity(argc, 0, 1) == 0) {
        super = rb_cObject;
    }
    else {
        super = argv[0];
        rb_check_inheritable(super);
        if (!RCLASS_INITIALIZED_P(super)) {
            rb_raise(rb_eTypeError, "can't inherit uninitialized class");
        }
    }
    rb_class_set_super(klass, super);
    RCLASS_SET_MAX_IV_COUNT(klass, RCLASS_MAX_IV_COUNT(super));
    RCLASS_SET_ALLOCATOR(klass, RCLASS_ALLOCATOR(super));
    rb_make_metaclass(klass, RBASIC(super)->klass);
    rb_class_inherited(super, klass);
    rb_mod_initialize_exec(klass);

    return klass;
}

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.

If a block is given, it is passed the class object, and the block is evaluated in the context of this class like class_eval.

fred = Class.new do
  def meth1
    "hello"
  end
  def meth2
    "bye"
  end
end

a = fred.new     #=> #<#<Class:0x100381890>:0x100376b98>
a.meth1          #=> "hello"
a.meth2          #=> "bye"

Assign the class to a constant (name starting uppercase) if you want to treat it like a regular class.

Public Instance Methods

allocate() → obj

() → untyped

Source

static VALUE
rb_class_alloc(VALUE klass)
{
    RBIMPL_ASSERT_TYPE(klass, T_CLASS);
    rb_alloc_func_t allocator = class_get_alloc_func(klass);
    return class_call_alloc_func(allocator, klass);
}

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

attached_object → object

() → untyped

Source

VALUE
rb_class_attached_object(VALUE klass)
{
    if (!RCLASS_SINGLETON_P(klass)) {
        rb_raise(rb_eTypeError, "'%"PRIsVALUE"' is not a singleton class", klass);
    }

    const VALUE obj = RCLASS_ATTACHED_OBJECT(klass);

    /* A singleton class is shareable whatever it is attached to, so another Ractor can
     * hold one attached to an unshareable object.  Returning it would share it. */
    if (rb_objspace_foreign_object_p(obj) && !RB_OBJ_SHAREABLE_P(obj)) {
        /* No klass in the message: naming a singleton class inspects the very object we
         * must not touch from here. */
        rb_raise(rb_eRactorIsolationError,
                 "can not get an unshareable attached object from another Ractor");
    }

    return obj;
}

Returns the object for which the receiver is the singleton class.

Raises an TypeError if the class is not a singleton class.

Raises a Ractor::IsolationError if the attached object is not shareable and belongs to another Ractor.

class Foo; end

Foo.singleton_class.attached_object        #=> Foo
Foo.attached_object                        #=> TypeError: `Foo' is not a singleton class
Foo.new.singleton_class.attached_object    #=> #<Foo:0x000000010491a370>
TrueClass.attached_object                  #=> TypeError: `TrueClass' is not a singleton class
NilClass.attached_object                   #=> TypeError: `NilClass' is not a singleton class

new(args, ...) → obj

(*untyped, **untyped) ?{ (?) → untyped } → untyped

Source

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

    obj = rb_class_alloc(klass);
    rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS);

    return obj;
}

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.

subclasses → array

() → Array[Class]

Source

VALUE
rb_class_subclasses(VALUE klass)
{
    return class_descendants(klass, true);
}

Returns an array of classes where the receiver is the direct superclass of the class, excluding singleton classes. The order of the returned array is not defined.

class A; end
class B < A; end
class C < B; end
class D < A; end

A.subclasses        #=> [D, B]
B.subclasses        #=> [C]
C.subclasses        #=> []

Anonymous subclasses (not associated with a constant) are returned, too:

c = Class.new(A)
A.subclasses        # => [#<Class:0x00007f003c77bd78>, D, B]

Note that the parent does not hold references to subclasses and doesn’t prevent them from being garbage collected. This means that the subclass might disappear when all references to it are dropped:

# drop the reference to subclass, it can be garbage-collected now
c = nil

A.subclasses
# It can be
#  => [#<Class:0x00007f003c77bd78>, D, B]
# ...or just
#  => [D, B]
# ...depending on whether garbage collector was run

superclass → a_super_class or nil

() → Class?

Source

VALUE
rb_class_superclass(VALUE klass)
{
    RUBY_ASSERT(RB_TYPE_P(klass, T_CLASS));

    VALUE *superclasses = RCLASS_SUPERCLASSES(klass);
    size_t superclasses_depth = RCLASS_SUPERCLASS_DEPTH(klass);

    if (klass == rb_cBasicObject) return Qnil;

    if (!superclasses) {
        RUBY_ASSERT(!RCLASS_SUPER(klass));
        rb_raise(rb_eTypeError, "uninitialized class");
    }

    if (!superclasses_depth) {
        return Qnil;
    }
    else {
        VALUE super = superclasses[superclasses_depth - 1];
        RUBY_ASSERT(RB_TYPE_P(super, T_CLASS));
        return super;
    }
}

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 does not have a parent class:

BasicObject.superclass   #=> nil

Private Instance Methods

inherited(subclass)

(Class subclass) → void

Source

#define rb_obj_class_inherited rb_obj_dummy1

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