Context: I'm programming a MUD in Ruby for fun and profit--if one  
considers that an increase in knowledge == profit. :)

Up to this point, I've only ever done web work with Ruby using Rails,  
Merb, etc., so I wanted to embark on a from-scratch project, and MUDs  
happen to be a favorite old pastime of mine ;)

One of the things I'm trying to do is implement a development server  
that "reloads" my source files automatically when they're updated,  
just like Rails or Merb does. Meaning that I can connect to the MUD  
server and explore with my test character, while updating my source  
files to change behavior around on the fly.

So, reading through Merb's way of doing it, I've gathered that in  
order to properly "reload a class", one must use remove_const to  
"undefine" the Class constant, and then use Kernel.load to reload the  
Class' source file. Simple stuff, and with a separate thread that  
continuously monitors my source files for changes in their  
modification time, we're golden. It works great.... with one exception.

What about objects of a Class that were already instantiated -- before  
the Class is reloaded with its changes? Those objects are essentially  
still bound to the "old" Class, I've found, and do not reflect the  
reloaded Class's changes. This doesn't really affect Rails or Merb,  
since Controller and Model instances do not persist between HTTP  
requests, but it certainly affects a MUD, where my test character (and  
basically everything else) is always in the object space.

The following IRB session demonstrates: (also on pastie: http://pastie.org/258400)

     >> puts File.read('foo.rb')
     class Foo
       def hello
         "Hello, world!"
       end
     end
     => nil
     >> require 'foo'
     => true
     >> f = Foo.new
     => #<Foo:0x117fbb4>
     >> f.hello
     => "Hello, world!"

     # Now I update foo.rb...

     >> puts File.read('foo.rb')
     class Foo
       def hello
         "BRAND NEW Hello World!"
       end
     end
     => nil

     # Reload the file using remove_const and Kernel.load

     >> Object.send(:remove_const, :Foo)
     => Foo
     >> Kernel.load('foo.rb')
     => true

     # Existing instance of Foo DOES NOT use the updated method.

     >> f.hello
     => "Hello, world!"

     # New object DOES use the updated method.

     >> f2 = Foo.new
     => #<Foo:0x112c6f8>
     >> f2.hello
     => "BRAND NEW Hello World!"


So here's the question -- is there some way to get an object to...  
erm, "reset" its Class? Sounds like evil voodoo that could potentially  
make things explode, but I'd truly like to see this thing work :) If  
it's just not possible though, I can live with that.

BTW -- By not doing the remove_const on the Class, I can sort of get  
this to work, because reloading the file with Kernel.load will  
effectively just reopen the class definition, adding the new changes,  
but also not removing methods I've deleted. And this *does* make  
things explode, like DataMapper for one, and I get all kinds of  
"already initialized constant" warnings.

The only thing I can think of is to try to finagle a way to copy  
existing objects into the newly defined Class, using serialization or  
something crazy, but that sounds really messy and probably not worth it.

Any comments? -- ideas / thoughts / similar-experience / you're-an- 
idiot-for-even-trying-this? Thanks! :)

Brent