Fooling Ruby's case operator, ===, with proxy objects

Question

I'm trying to make a proxy object that transfers almost all method calls to a child object, essentially the delegator pattern. For the most part, I'm just using a BasicObject and passing every call with method_missing to the child object. So far, so good.

The trick is that try as I might, I can't fool Ruby's case operator, so I can't do:

x = Proxy.new(15)
Fixnum === x #=> false, no matter what I do

This of course makes any case x operations fail, which means the proxies can't be handed off safely to other libraries.

I can't for the life of me figure out what === is using. The proxy works fine for all of the class-based introspection I know of, which is all correctly passed to the child object:

x.is_a?(Fixnum) #=> true
x.instance_of?(Fixnum) #=> true
x.kind_of?(Fixnum) #=> true
x.class #=> Fixnum

Is Module#=== just doing some kind of magic that can't be avoided?

Answer 1

Yeah, it is. Module#=== is implemented in C, examining the object's class hierarchy directly. It doesn't look like there's a way to fool it.

Answer 2

The problem is that it does Fixnum === x, which means that the method === is called on Fixnum and not on x. You could replace all === methods in existence, (and also watch for when new === methods are introduced), but that would be a lot of work, and quite fragile.

Answer 3

Hi, you should probably do a search for the BlankSlate class. This class strips out most of the methods from a normal Object and the website has an example of a simple Proxy class that will print out all methods being called. This shoul give you a better picture of what is happening. Sorry I can't give you a fuller answer but I'm on my phone. Hope that helps.