BasicObject

        # BasicObject < Object

(from ruby core)
---

BasicObject is the parent class of all classes in Ruby.  It's an
explicit blank class.

BasicObject can be used for creating object hierarchies independent of
Ruby's object hierarchy, proxy objects like the Delegator class, or
other uses where namespace pollution from Ruby's methods and classes
must be avoided.

To avoid polluting BasicObject for other users an appropriately named
subclass of BasicObject should be created instead of directly modifying
BasicObject:

    class MyObjectSystem < BasicObject
    end

BasicObject does not include Kernel (for methods like `puts`) and
BasicObject is outside of the namespace of the standard library so
common classes will not be found without using a full class path.

A variety of strategies can be used to provide useful portions of the
standard library to subclasses of BasicObject.  A subclass could
`include Kernel` to obtain `puts`, `exit`, etc.  A custom Kernel-like
module could be created and included or delegation can be used via
#method_missing:

    class MyObjectSystem < BasicObject
      DELEGATE = [:puts, :p]

      def method_missing(name, *args, &block)
        return super unless DELEGATE.include? name
        ::Kernel.send(name, *args, &block)
      end

      def respond_to_missing?(name, include_private = false)
        DELEGATE.include?(name) or super
      end
    end

Access to classes and modules from the Ruby standard library can be
obtained in a BasicObject subclass by referencing the desired constant
from the root like `::File` or `::Enumerator`. Like #method_missing,
#const_missing can be used to delegate constant lookup to `Object`:

    class MyObjectSystem < BasicObject
      def self.const_missing(name)
        ::Object.const_get(name)
      end
    end

### What's Here

These are the methods defined for BasicObject:

    ::new
:       Returns a new BasicObject instance.

    [!](#method-i-21)
:       Returns the boolean negation of `self`: `true` or `false`.

    [!=](#method-i-21-3D)
:       Returns whether `self` and the given object are *not* equal.

    [==](#method-i-3D-3D)
:       Returns whether `self` and the given object are equivalent.

    [__id__](#method-i-__id__)
:       Returns the integer object identifier for `self`.

    [__send__](#method-i-__send__)
:       Calls the method identified by the given symbol.

    #equal?
:       Returns whether `self` and the given object are the same object.

    #instance_eval
:       Evaluates the given string or block in the context of `self`.

    #instance_exec
:       Executes the given block in the context of `self`, passing the
        given arguments.

    #method_missing
:       Method called when an undefined method is called on `self`.

    #singleton_method_added
:       Method called when a singleton method is added to `self`.

    #singleton_method_removed
:       Method called when a singleton method is added removed from
        `self`.

    #singleton_method_undefined
:       Method called when a singleton method is undefined in `self`.


---
# Class methods:

    new

# Instance methods:

    !
    !=
    ==
    __id__
    __send__
    equal?
    instance_eval
    instance_exec
    method_missing
    singleton_method_added
    singleton_method_removed
    singleton_method_undefined

(from gem debug-1.7.1)
---
# Instance methods:

    singleton_method_added