Dynamic method chain?

Question

How can I call a nested hash of methods names on an object?

For example, given the following hash:

hash = {:a => {:b => {:c => :d}}}

I would like to create a method that, given the above hash, does the equivalent of the following:

object.send(:a).send(:b).send(:c).send(:d)

The idea is that I need to get a specific attribute from an unknown association (unknown to this method, but known to the programmer).

I would like to be able to specify a method chain to retrieve that attribute in the form of a nested hash. For example:

hash = {:manufacturer => {:addresses => {:first => :postal_code}}}
car.execute_method_hash(hash)
=> 90210

Answer 1

I'd use an array instead of a hash, because a hash allows inconsistencies (what if there is more than one key in a (sub)hash?).

object = Thing.new
object.call_methods [:a, :b, :c, :d]

Using an array, the following works:

# This is just a dummy class to allow introspection into what's happening
# Every method call returns self and puts the methods name.
class Thing
  def method_missing(m, *args, &block)
    puts m
    self
  end
end

# extend Object to introduce the call_methods method
class Object
  def call_methods(methods)
    methods.inject(self) do |obj, method|
      obj.send method
    end
  end
end

Within call_methods we use inject in the array of symbols, so that we send every symbol to the result of the method execution that was returned by the previous method send. The result of the last send is automatically returned by inject.