Ruby Fu

This is an old one, but I tightened up the code a little bit. Take a look at the following:

module Enumerable
  def all
    MapProxy.new self
  end
end
class Enumerable::MapProxy
  instance_methods.each do |m|
    undef_method m unless m.to_s=~/^__(id|send)__$/
  end
  private
  def initialize proxied
    @proxied=proxied
  end
  def method_missing m,*a,&b
    @proxied.map{|o|o.__send__ m, *a, &b} # thanks, NiKA
  end
end

Basically it lets you write [1,2,3].all.to_s and get back ["1","2","3"]. It does so by creating an instance of the Enumerable::MapProxy class that dispatches any method you send it right on down to each element of the Enumerable object (an Array in the case of [1,2,3]). It's called MapProxy because it dispatches the method to each element by way of the #map method.

Its pretty convenient for some kinds of operations, but there's a downside to using Transparent Proxies-- I call them "Transparent" because as far as you can tell when you interact with it, it doesn't actually identify itself in the traditional way. If you say [1,2,3].all.class you don't get back a class, you get an Array of classes, which are the classes of the elements in the collection.

The downside therefore is that you get this object with extremely interesting behaviour, but don't really know what's going on unless you can figure out where the object came from.

If you use Rails, you already use Transparent Proxies, since the AssociationProxy class in the ActiveRecord::Associations module is a well-known example of one. In many ways the effect is seamless and great, but it can be the cause of some pretty bizarre behaviour, especially in light of the way it chooses to direct method_missing calls back down to the class the association represents.

For example, did you know that if you have a belongs_to :customer association on your Order class, that @order.belongs_to actually returns an instance of the AssociationProxy class?

If you are ever stuck with an object that you "think" might be an instance of a specific Transparent Proxy class, here is a handy way to find out:

class Class
  def one_of_me? object
    ObjectSpace.each_object(self) do |o|
      return true if o.__id__==object.__id__
    end
    return false
  end
end

# to demonstrate...

Enumerable::MapProxy.
  one_of_me?([1,2,3].all) #<= true

ActiveRecord::Associations::AssociationProxy.
  one_of_me?(@order.customer) #<= true

Labels: method_missing, ObjectSpace, ruby, transparent proxies