class Class
Extends any Class to include json_creatable? method.
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 class 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 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)-|-... | ^ | | ^ | | | | | | | | Class-|---------|---->(Class)-|-... | ^ | | ^ | | +---+ | +----+ | | obj--->OtherClass---------->(OtherClass)-----------...
Public Class Methods
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 using 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.
static VALUE rb_class_initialize(int argc, VALUE *argv, VALUE klass) { VALUE super; if (RCLASS_SUPER(klass) != 0 || klass == rb_cBasicObject) { 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); if (super != rb_cBasicObject && !RCLASS_SUPER(super)) { rb_raise(rb_eTypeError, "can't inherit uninitialized class"); } } 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
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; rb_alloc_func_t allocator; 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"); } allocator = rb_get_alloc_func(klass); if (!allocator) { rb_raise(rb_eTypeError, "allocator undefined for %"PRIsVALUE, klass); } #if !defined(DTRACE_PROBES_DISABLED) || !DTRACE_PROBES_DISABLED if (RUBY_DTRACE_OBJECT_CREATE_ENABLED()) { const char * file = rb_sourcefile(); RUBY_DTRACE_OBJECT_CREATE(rb_class2name(klass), file ? file : "", rb_sourceline()); } #endif obj = (*allocator)(klass); if (rb_obj_class(obj) != rb_class_real(klass)) { rb_raise(rb_eTypeError, "wrong instance allocation"); } return obj; }
Returns true if this class can be used to create an instance from a serialised JSON string. The class has to implement a class method json_create that expects a hash as first parameter. The hash should include the required data.
# File ext/json/lib/json/common.rb, line 485 def json_creatable? respond_to?(:json_create) end
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; }
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
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 (RB_TYPE_P(super, T_ICLASS)) { super = RCLASS_SUPER(super); } if (!super) { return Qnil; } return super; }
Private Instance Methods
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; }