Using define_method with blocks in Ruby 1.8

It’s pretty well known that because of a deficiency in blocks arguments in Ruby 1.8 Class#define_method cannot define methods that take blocks.

def x *args, █ end  # => works!
define_method(:x) {|*args,&block| } # => SyntaxError: compile error

This really sucks when you need to define methods dynamically which take blocks. Sometimes you have to define the method dynamically because it needs access to variables in the current scope. If you were to use the def syntax the scope changes and those variables would no longer be accessible. For example:

var1 = x
var2 = y
def my_method &block
  block.call(var1*var2) # => undefined local variable or method `var1'
end

I came up with a simple workaround for this

  var1 = x
  var2 = y
  define_method(:__real__my_method) do |block, *args|
    block.call(var1*var2)
  end

  def my_method(*args, &block)
    __real__my_method(block, *args)
  end

We create a special “real” method which takes the block as the normal first parameter instead of as the special block parameter. Then we create a proxy method, with the name that we want to use in our code, which simply re-arranges the parameters (putting the block first) and calls the “real” method.

There’s one other possible issue. Since the method we’ll be calling from our code is still being defined with a def you might be complaining that you can’t set its name dynamically. Well there are two ways to do this. One is to just eval a string:

  eval <<-EOM
    def #{dynamic_name}(*args, &block)
      __real__#{dynamic_name}(block, *args)
    end
  EOM

Sometimes though, you wan’t to use a name which has characters that the ruby parser won’t allow you to use with the def syntax. This can be accomplished with a temporary method name and a alias_method:

  eval <<-EOM
    def __temp_method__(*args, &block)
      __send__("__real__#{dynamic_name}", block, *args)
    end
  EOM
  alias_method dynamic_name, :__temp_method__
  remove_method :__temp_method__