Question

I’ve got a library module I’d like to override based on the rails environment I’m running in

Module is located in lib/package/my_module.rb:

module Package
  module MyModule
    puts "Defining original module"
    def foo
      puts "This is the original foo"
    end
  end
end

I have been able to partially solve with the info at Overriding a module method from a gem in Rails – specifically, in my environments/dev_stub.rb:

Package::MyModule.module_eval do
 puts "Defining override"
 def foo
   puts "This is foo override"
 end
end

(The other solution at that link seems to cause errors when rails tries to lookup other classes related to package)

Now, this seems to get me most of the way there, and works if I set

config.cache_classes = true

…but I want to use this as a stub development environment, and the comment recommendation on this value for a dev environment is to use false… in which case the override only works the first time the module is included, and any subsequent times, it uses the original.

My question: Am I going about this the right way? I could hack up the lib module itself to conditionally override based on RAILS_ENV, but I’d like to keep it cleaner than that…

Edit

My use case for this is to reference it from a controller function. If I have

class SomethingController < ApplicationController
  def show
    Package::MyModule.foo
  end
end

and config.cache_classes=false (which I ideally want since it is a development environment), and access the action through my web browser (http://localhost/something/show) then the first time I hit it, my override is loaded and it works, but the second and any subsequent times, the original library class is reloaded (outputs “Defining original module” on my console without “Defining override”), and the override is lost.

Another alternative I tried was add something like config.load_paths += %W( #{RAILS_ROOT}/lib_patch/#{RAILS_ENV}) to environment.rb – but defining the same module/class didn’t quite work without putting in an explicit hook in the original library to basically load the patch if it existed

Edit 2 (in response to @apneadiving answer)

I’ve tried doing this without module_eval, and just using the following in development_stub.rb:

require 'package/my_module'
module Package
  module MyModule
    puts "Defining override"
    def foo
      puts "This is foo override"
    end
  end
end

The problem I initially had with doing this is that Rails no longer automatically finds all content in my lib directory, and I need to sprinkle ‘require’ statements throughout all other lib files (and my controllers that reference the libs) to cover all of their dependencies. Although this is all done, it does work, but it also has a similar effect as config.cache_classes=true does, in that all the lib classes are not reloaded on change, even in my regular development environment that does not have a monkey-patch (since all the ‘require’ statements are added).

Answer 1

Setting config.cache_classes=true in dev_stub.rb and using module_eval to define the patch as described in the question seems the way to go for what the goal is here – to create an environment specific patch for a module that doesn’t impact the other environments in both code path and Rails class loading behavior.