Question

I would like to do some fairly heavy-duty reflection in Ruby. I want to create a function that returns the names of the arguments of various calling functions higher up the call stack (just one higher would be enough but why stop there?). I could use Kernel.caller, go to the file and parse the argument list but that would be ugly and unreliable.

The function that I would like would work in the following way:

module A   def method1( tuti, fruity)      foo   end   def method2(bim, bam, boom)       foo   end   def foo     print caller_args[1].join(',') #the '1' mean one step up the call stack   end  end  A.method1  #prints 'tuti,fruity' A.method2  #prints 'bim, bam, boom' 

I would not mind using ParseTree or some similar tool for this task but looking at Parsetree, it is not obvious how to use it for this purpose. Creating a C extension like this is another possibility but it would be nice if someone had already done it for me.

I can see that I’ll probably need some kind of C extension. I suppose that means my question is what combination of C extension would work most easily. I don’t think caller+ParseTree would be enough by themselves.

As far as why I would like to do this goes, rather than saying ‘automatic debugging’, perhaps I should say that I would like to use this functionality to do automatic checking of the calling and return conditions of functions:

def add x, y    check_positive   return x + y end 

Where check_positive would throw an exception if x and y weren’t positive. Obviously, there would be more to it than that but hopefully this gives enough motivation.

Answer 1

I suggest you take a look at Merb’s action-args library.

require 'rubygems' require 'merb'  include GetArgs  def foo(bar, zed=42) end  method(:foo).get_args # => [[[:bar], [:zed, 42]], [:zed]] 

If you don’t want to depend on Merb, you can choose and pick the best parts from the source code in github.