Better way to turn a ruby class into a module than using refinements?

I am happy indeed with Ruby 2.1 (and later) class-level "private" scope of refinements. My example above can be rephrased as:

# spec/modulify_spec.rbmodule Modulify  refine(Class) do    def include_refined(klass)      _refined = Module.new do        include refine(klass) { yield if block_given? }      end      include _refined    end  endendclass A  def a    "I am an 'a'"  endendclass B  using Modulify  include_refined(A) do    def a      super + " and not a 'b'"    end  end  def b    "I cannot say: " + a  endendRSpec.describe B do  it "can use refined methods from A" do    expect(subject.b).to eq "I cannot say: I am an 'a' and not a 'b'"  endend

and suits as solution for the original problem.

Andrea, thank you for the info in comment. Excuse my lack of knowledge to understand this is really necessary though it sounds doable as per your research.

I don't think we need to go so low level to do something in Rails.

If I'm going to do similar on Engine, I will try the following ideas, from easy to hard.

1. In routes.rb, mount the whole engine in right route.

   I'm afraid this most common usage can't fit your need

2. In routes.rb, Customize engine's route for specific controllers in application route.

   Devise, as an engine, can do easily. But I know not every engine could do this.

3. In routes.rb, redirect specific or whole set of routes to engine's routes

4. In your application's action, redirect to specific engine's action in application's action.

   This should be customized enough for specific action

   class FoosController < ApplicationController  def foo    redirect_to some_engine_path if params[:foo] == 'bar'  end

5. Inherit the engine's controller - for a set of actions, and if all above can't fit

   *The engine's classes are available in all application, you can inherit a controller from them, instead of normal ApplicationController.

   # class FoosController < ApplicationControllerclass FoosController < BarEngine::BarsController

   *Since most engine's controller inherit from ApplicationController, this inheritance still allows you to use your own things from ApplicationController, no bad effect at all.

6. If all above can't do, I can try to serve a customized locally or from my github repo.

In conclusion, the above should be able to solve most of cases, and I myself prefer #5 when possible and needed.