Thanks, thats what I want.

Looking around, I can't seem to find a way to introspect the stack,
other than that. I.e., to look at my callers context, see what it's
local variables are, etc.

This kind of feature would be interesting, I could do

def pp_local
  ctx = stack[1] # assume current stack is stack[0]
  puts "in method #{ctx.method_name},"
  ctx.locals.each { |sym, o|
    print "#{sym} has value "
    pp o
  end
end

Is anything like this currently possible?

Thanks,
Sam

Quoteing dave / pragprog.com, on Sun, Mar 07, 2004 at 04:47:25AM +0900:
> On Mar 6, 2004, at 13:29, Sam Roberts wrote:
> 
> >I want a version of "pp" that prints the file/line, so I tried this:
> >
> >def debug(*objs)
> >  print __FILE__, ':', __LINE__, ':'
> >  pp(*objs)
> >end
> 
> Have a look at Kernel#caller
> 
> dave[Downloads/emacs 13:46:32] ri caller
> ---------------------------------------------------------- Kernel#caller
>      caller(start=1)    => array
> ------------------------------------------------------------------------
>      Returns the current execution stack---an array containing strings
>      in the form ``file:line'' or ``file:line: in `method'''. The
>      optional start parameter determines the number of initial stack
>      entries to omit from the result.
> 
>         def a(skip)
>           caller(skip)
>         end
>         def b(skip)
>           a(skip)
>         end
>         def c(skip)
>           b(skip)
>         end
>         c(0)   #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", 
> "prog:10"]
>         c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11"]
>         c(2)   #=> ["prog:8:in `c'", "prog:12"]
>         c(3)   #=> ["prog:13"]
> 
> 
> 
> Cheers
> 
> Dave
> 
>