Using introspection to get method arguments and other info

#!/usr/bin/env ruby
# Copyright (c) 2006 Mauricio Fernandez <mfp@acm.org>
#                    http://eigenclass.org
# Use and distribution subject to the same conditions as Ruby.


$VERBOSE = nil
$__method_args_off = true

if ARGV.empty?
  puts <<EOF
ruby method_args.rb [-i] [-m] [-c] <file> [<file> ...]

-i    omit instance methods defined in classes
-m    omit instance methods defined in modules
-c    omit class methods

The given files will be #require()d in order.
Examples:
  ruby method_args.rb complex
  ruby method_args.rb thread
  ruby method_args.rb -c rubygems
EOF
  exit
end

module MethodArgs
  MAX_ARGS = 20

  def output_method_info(klass, object, meth, is_singleton = false)
    return if $__method_args_off
    file = line = params = values = nil
    unless %w[initialize].include?(meth.to_s)
      if is_singleton
        return if class << klass; private_instance_methods(true) end.include?(meth.to_s)
      else
        return if class << object; private_instance_methods(true) end.include?(meth.to_s)
      end
    end
    arity = is_singleton ? object.method(meth).arity : klass.instance_method(meth).arity
    set_trace_func lambda{|event, file, line, id, binding, classname|
      begin
        #puts "!EVENT: #{event} #{classname}##{id}, #{file} #{line}"
        #puts "(#{self} #{meth})"
        if event[/call/] && classname == self && id == meth
          params = eval("local_variables", binding)
          values = eval("local_variables.map{|x| eval(x)}", binding)
          #puts "EVENT: #{event} #{classname}##{id}"
          throw :done
        end
      rescue Exception
      end
    }
    variadic_with_block = false
    if arity >= 0
      num_args = arity
      catch(:done){ object.send(meth, *(0...arity)) }
    else
      num_args = 0
      # determine number of args (including splat & block)
      MAX_ARGS.downto(arity.abs - 1) do |i|
        catch(:done) do 
          begin
            object.send(meth, *(0...i)) 
          rescue Exception
          end
        end
        # all nils if there's no splat and we gave too many args
        next if !values || values.compact.empty? 
        k = nil
        values.each_with_index{|x,j| break (k = j) if Array === x}
        if k
          num_args = k+1
        else
          num_args = i
        end
        break
      end
      # determine if it's got a block arg
=begin
      30.downto(arity.abs - 1) do |i|
        catch(:done) { object.send(meth, *(0...i)) }
        next if values.compact.empty?
        variadic_with_block = true if values[-1] == nil
      end
=end
      args = (0...arity.abs-1).to_a
      catch(:done) do 
        args.empty? ? object.send(meth) : object.send(meth, *args)
      end
    end
    set_trace_func(nil)
    
    if local_variables == params
      puts "#{klass}#{is_singleton ? "." : "#"}#{meth} (...)"
      return
    end
    
    fmt_params = lambda do |arr, arity|
      arr.inject([[], 0]) do |(a, i), x|
        if Array === values[i] 
          [a << "*#{x}", i+1] 
        else
          if arity < 0 && i >= arity.abs - 1
            [a << "#{x} = #{values[i].inspect}", i + 1]
          else
            [a << x, i+1]
          end
        end
      end.first.join(", ")
    end
    params ||= []
    params = params[0,num_args]
    #unfortunately, there's no way to tell the block arg from the first local
    #since its value will be nil even if we pass a block
    #if arity >= 0 && params[arity] # or variadic_with_block
    #  arg_desc = "(#{fmt_params.call(params[0..-2], arity)}, &#{params.last})"
    #else
    arg_desc = "(#{fmt_params.call(params, arity)})"
    #end
      

    puts "#{klass}#{is_singleton ? "." : "#" }#{meth} #{arg_desc}"
    rescue Exception
      #puts "GOT EXCEPTION while processing #{klass} #{meth}"
      #puts $!.message
      #puts $!.backtrace
      puts "#{klass}#{is_singleton ? "." : "#"}#{meth} (...)"
    ensure
      set_trace_func(nil)
  end
end



new_args = []
omissions = {}

ARGV.each do |arg|
  case arg
  when /-./; omissions[$&] = true
  else new_args << arg
  end
end

ARGV.replace new_args

class Object
  include MethodArgs
  def self.method_added(meth)
    if [Integer, Fixnum, Bignum, Float].include? self or
        defined?(Digest::Base) && Digest::Base == self
      puts "#{self}##{meth} (...)"
      return
    end
    begin
      o = self.allocate
    rescue Exception
      p $!
    end
    output_method_info(self, o, meth, false)
  end
end unless omissions["-i"]

class Module
  method_added = instance_method(:method_added)
  define_method(:method_added) do |meth|
    begin
      if instance_of? Module
        o = Object.new
        o.extend(self)
        output_method_info(self, o, meth, false)
      end
      method_added.bind(self).call(meth)
    rescue Exception
      puts "#{self}##{meth} (...)"
    end
  end
end unless omissions["-m"]


class Class
  def singleton_method_added(meth)
    output_method_info(self, self, meth, true)
  rescue Exception
    puts "#{self}.#{meth} (...)"
  end
end unless omissions["-c"]


$__method_args_off = false

ARGV.each{|x| require x}

END { puts "zzzz OK" }