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 code describing the class behavior

When a new class is created, an object of type Class is initialized and assigned to a global constant (Name in this case).

When 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 ",, "\n"

class Name

n =


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’.

                         +---------+             +-...
                         |         |             |
             ^           |         ^             |
             |           |         |             |
             ^           |         ^             |
             |           |         |             |
             +-------+   |         +--------+    |
             |       |   |         |        |    |
             |    Module-|---------|--->(Module)-|-...
             |       ^   |         |        ^    |
             |       |   |         |        |    |
             |     Class-|---------|---->(Class)-|-...
             |       ^   |         |        ^    |
             |       +---+         |        +----+
             |                     |
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 like class_eval.

fred = do
  def meth1
  def meth2

a =     #=> #<#<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.

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 = do
  def initialize(*args)
    @initialized = true

  def initialized?
    @initialized || false

klass.allocate.initialized? #=> false

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


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

class Bar < Foo

class Baz < Bar


New subclass: Bar
New subclass: Baz

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.

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.

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        #=> []

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