How do I cleanly "reattach" a detached method in Ruby? - ruby

Question

Say I have this class:
class Foo
def destroy_target(target)
Missile.launch(target)
end
end
I want to temporarily neuter the destructive power of Foo, for example for testing purposes, so I do this:
backup = Foo.instance_method(:destroy_target)
class Foo
def destroy_target(target)
Pillow.launch(target)
end
end
Here's my question: how do I "reattach" the original method to Foo, as if it was never overridden in the first place?
I realize I can do this:
class Foo
def destroy_target(target)
backup.bind(self).call(target)
end
end
But obviously this is not optimal, as I'm now wrapping the original function. I want to be able to detach and reattach the method an indefinite amount of times without adding any overhead.
Asked a different way; how do I attach a DetachedMethod to a class "properly", i.e. without defining a new method that calls the detached one.
Note: I am not interested in alternative ways of temporarily changing the functionality of a class. I specifically want to know how to replace a method with a different method, then restore the original method cleanly.

Answer 1

I tested your first example, and it seems to work fine. I couldn't find any side-effect, but it doesn't mean there isn't.
Did you consider refinements?
For a Class
class Missile
def self.launch(t)
puts "MISSILE -> #{t}"
end
end
class Pillow
def self.launch(t)
puts "PILLOW -> #{t}"
end
end
class Foo
def destroy_target(target)
Missile.launch(target)
end
end
module PillowLauncher
refine Foo do
def destroy_target(target)
Pillow.launch(target)
end
end
end
module Test
using PillowLauncher
Foo.new.destroy_target("Tatooine")
#=> PILLOW -> Tatooine
end
Foo.new.destroy_target("Tatooine")
#=> MISSILE -> Tatooine
It might bring the advantage of being a bit more standard and understandable than your example.
For a Module
If Foo is a Module, you cannot call refine Foo directly, you'd get a TypeError: wrong argument type Module (expected Class).
You can, however, refine its singleton_class :
module Foo
def self.destroy_target(target)
Missile.launch(target)
end
end
module PillowLauncher
refine Foo.singleton_class do
def destroy_target(target)
Pillow.launch(target)
end
end
end
module Test
using PillowLauncher
Foo.destroy_target('Tatooine')
#=> PILLOW -> Tatooine
end
Foo.destroy_target('Tatooine')
#=> MISSILE -> Tatooine
I'm not sure about your note :
I am not interested in alternative ways of temporarily changing
the functionality of a class. I specifically want to know how to
replace a method with a different method, then restore the original
method cleanly.
My proposed code seems to do both.

Answer 2

This appears to work:
Foo.instance_exec {
define_method(:destroy_target, backup)
}
But I'm not completely sure if this is side effect free. If somebody knows for sure I'd appreciate a comment.
This also appears to work if Foo is a module defined like this:
module Foo
extend self
def destroy_target(target)
Missile.launch(target)
end
end