Open class definitions in ruby allow libraries to add functionality to existing objects. Standard practice is to define a module with the new functionality and include it into the existing class ( Jay fields on the subject here ). Unfortunately this model breaks when you want to update a module.
For instance the following doesn’t work:
module ExampleModule def original_method end end class ExampleClass include ExampleModule end #re-open the module and extend module ExampleModule module Extension def extension_method end end include Extension end obj = ExampleClass.new obj.original_method #OK obj.extension_method #nope!
For whatever reason in ruby 1.9 at least changes to the inclusions of the module are not automatically seen in the class the way a new method in the module itself would be.
Unfortunately there doesn’t appear to be a good way around this. One option is to re-open and directly modify the module, which is what we’re trying to avoid. The other option is to re-include the module after extending it as follows:
class ExampleClass include ExampleModule end obj.extension_method #OK
Unfortunately if you are using open classes as an extension mechanism you are opening yourself up for a lot of confusing problems. Why? Suppose my extension used a module to override original_method (originally provided by ExampleModule) in ExampleClass
module OverrideOriginalMethod def original_method end end class ExampleClass include OverrideOriginalMethod end #...update example module... #reinclude ExampleModule so changes take effect class ExampleClass include ExampleModule end obj.extension_method #OK #oops! This is ExampleModule::original_method obj.original_method