Delegator through BasicObject transparency
===

**Context**: I am trying to put up a Decorator pattern in Ruby. As a Decorator should delegate all unknown methods to the underlying objects, I used the Delegator class. 
I could have used SimpleDelegator but I wanted to fully understand what I was doing.

So the basic code I came out with was :

    class Decorator < Delegator
      def initialize(component)
        super
        @component = component
      end
    
      def __setobj__(o); @component = o   end
      def __getobj__;    @component       end
      def send(s, *a);   __send__(s, *a)  end
    end

Which is ~exactly the same as the implementation of SimpleDelegator. Seems good.

But the thing I did not want was for the code handling the Decorator to know it is manipulating a Decorator. I want full transparency.

At this moment `Decorator.new(Object.new).class` returned `Decorator`

So I tinkered a bit and came up with this :

    class Decorator < Delegator
      undef_method :==
      undef_method :class
      undef_method :instance_of?
    
      # Stores the decorated object
      def initialize(component)
        super
        @component = component
      end
    
      def __setobj__(o); @component = o   end
      def __getobj__;    @component       end
      def send(s, *a);   __send__(s, *a)  end
    end

This way, I can safely use `class` or `instance_of?` on my Decorated object, it will send the method to the underlying object via method_missing (which is implemented by Delegator).

The thing is : I don't understand why I had to undef `:class` and `:instance_of?`. I can see that BasicObject defines `:==` so I had to undefine it but what about those two ?
I looked at the BasicObject documentation and a bit in the C code but did not find anything. I looked the same at the Delegator documentation and code, and did not find anything either.
It seems Delegator include the Kernel module, but Kernel#class or Kernel#instance_of? don't  exist.

Where those two method came from ? Why did I need to undefine them if they were not implemented at all ?
I guess I must be missing something about Ruby's object model or something.

Thanks.