Question

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.

Answer 1

You can get a hint by inspecting the method:

Decorator.instance_method(:class)
  # =>  #<UnboundMethod: Decorator(#<Module:0x00000102137498>)#class> 

The method’s owner is Decorator but actually defined in #<Module:0x00000102137498>. So there is an anonymous module that defines it. Interesting… let’s look at:

Decorator.ancestors
  # => [Decorator, Delegator, #<Module:0x00000102137498>, BasicObject] 

There’s that module again, between Delegator and BasicObject. So Delegator doesn’t directly derive from BasicObject. If you look at the source code in lib/delegate.rb you find:

class Delegator < BasicObject
  kernel = ::Kernel.dup
  kernel.class_eval do
    [:to_s,:inspect,:=~,:!~,:===,:<=>,:eql?,:hash].each do |m|
      undef_method m
    end
  end
  include kernel
  # ...

So a copy of the Kernel module is made, which doesn’t have to_s, inspect, etc… but still has class and instance_of?. It’s included in Delegator and that’s where they come from.

Note that Object inherits the same methods by including the Kernel module (but it includes the full module, of course):

42.method(:class) # => #<Method: Fixnum(Kernel)#class>

This is stated in the Object doc:

Object mixes in the Kernel module, making the built-in kernel
functions globally accessible. Although the instance methods of Object
are defined by the Kernel module, we have chosen to document them here
for clarity.