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

问题

Module#refine method takes a class and a block and returns a refinement module, so I thought I could define:

class Class
  def include_refined(klass)
    _refinement = Module.new do
      include refine(klass) {
        yield if block_given?
      }
    end
    self.send :include, _refinement
  end
end

and the following test passes

class Base
  def foo
    "foo"
  end
end

class Receiver
  include_refined(Base) {
    def foo
      "refined " + super
    end
  }
end

describe Receiver do
  it { should respond_to(:foo) }
  its(:foo) { should eq("refined foo") }
end

So, using refinements, I can turn a class into a module, refine its behaviour on the fly, and include it in other classes.

• Is there a simpler way to turn a class into a module in Ruby (say in ruby < 2)?

• In the C-implementation of rb_mod_refine we see

  refinement = rb_module_new();
  RCLASS_SET_SUPER(refinement, klass);
  

  Is this just setting the superclass of refinement to klass that copies the implementation of the class inside the refinement module?

• I am aware that multiple inheritance IS done via Modules, but what would the community think of the above Class#include_refined? Would it be reasonable to extract this aspect out of refinements? "Locally" patching inside a Class instead of using "using" switches to activate refinements?

回答1:

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.rb
module Modulify
  refine(Class) do
    def include_refined(klass)
      _refined = Module.new do
        include refine(klass) { yield if block_given? }
      end
      include _refined
    end
  end
end

class A
  def a
    "I am an 'a'"
  end
end

class B
  using Modulify

  include_refined(A) do
    def a
      super + " and not a 'b'"
    end
  end

  def b
    "I cannot say: " + a
  end
end

RSpec.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'"
  end
end

and suits as solution for the original problem.

回答2:

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 < ApplicationController
   class 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.

来源：https://stackoverflow.com/questions/18551058/better-way-to-turn-a-ruby-class-into-a-module-than-using-refinements