In the last post we looked at the hoops we had to go through to redefine a method on a single instance using a closure. In this post we’ll look at ways to make this easier on ourselves.

I should stress that I’m a Ruby n00bie, so take this all with a grain of salt. Please let me know if I’ve got it wrong.

First attempt

We found out last time that to add an instance method to a single object using a closure we had to obtain a reference to that instance’s metaclass (or eigenclass as it is also known) using the class << instance syntax. We could then use the metaclass’s private define_method via the send method.

class Greeter
    def say_hello
        puts "Hello World!"
    end
end
greeters_metaclass = class << greeter; self; end
greeters_metaclass.send(:define_method, :say_hello) do
    puts "G'day #{name}"
end
greeter.say_hello
#=> G'day Anonymous Dave

We can make this a bit easier by extracting this into a method. If we put it in a Ruby module, we can open up any class or instance and import this code as required.

module Meta
    def define(name, &block)
        meta = class << self; self; end
        meta.send(:define_method, name, block)
    end
end

And this works the same way as the previous code, just a bit neater:

# Open up Greeter class and import the Meta module:
class Greeter
    include Meta
end

# Our greeter gains the new syntax:
name = "Anonymous Dave"
greeter.define(:say_hello) do
    puts "G'day #{name}"
end

greeter.say_hello
#=> G'day Anonymous Dave

We can do better.

Second attempt

It would be really nice to be able to just write greeter.define.say_hello { puts "blah" }. Let’s make it work. We’ll need to make a define method that returns some sort of object that responds to any method, whether it exists or not. Ruby has a handy method_missing method we can define which will be invoked in the event it cannot resolve a particular method. We can just move the method creation into there:

module Meta
    def define
        meta = class << self; self; end
        Creator.new(meta)
    end
    class Creator
        def initialize(meta)
            @meta = meta
        end
        def method_missing(symbol, *args, &block)
            @meta.send(:define_method, symbol, block)
        end
    end
end

This then gives us a nicer syntax whenever we import the module:

name = "Anonymous Dave"
greeter.define.say_hello do
    puts "G'day #{name}"
end
greeter.say_hello
#=> G'day Anonymous Dave


greeter.define.say_hello do
    puts "Howdy!"
end
greeter.say_hello
#=> Howdy!

Parting thoughts

Like I said, I’m new to this stuff and have absolutely no idea if this is completely terrible. I do know that I’m really impressed with how easily even a newbie like me could add the syntax I wanted to absolutely everywhere in Ruby I could possibly need it, in a fairly neat and reusable way.