装饰 Rails 引擎的助手以包含来自主应用程序的关注

Question

I would like to include an ActiveSupport::Concern from an app in an engine, by decorating one of the engine's helper modules. Here is the Helper from the engine:

module MyEngine
  module MyHelper
  end
end

Here is the Concern from the main app :

module MyConcern
  extend ActiveSupport::Concern

  def do_this
  end

  def do_that
  end
end

Below is the decorated engine helper that needs to include the concern (for use in the engine views) - it is declared in the main app , using the decorator pattern described in the Rails guides :

module MyEngine
  module MyHelper
    include MyConcern

    def do_stuff
    end
  end
end

The decorated helper is properly loaded by the engine, but the engine views are only able to call "do_stuff". The methods from MyConcern are unavailable, and I'm having a hard time figuring out why. I also tried to include the concern by embedding it in a MyEngine::MyHelper.module_eval call, but that didn't work either.

Has anyone faced this kind of issue before ? Am I taking this the wrong way ?

Answer 1

I renplaced MyHelper from module to class

module MyConcern
  extend ActiveSupport::Concern

  def do_this
    "do this"
  end

  def do_that
    "do that"
  end
end

module MyEngine
  class MyHelper
    include ::MyConcern

    def do_stuff
      "do stuff"
    end
  end
end

When calling :

MyEngine::MyHelper.new.do_stuff
MyEngine::MyHelper.new.do_this
MyEngine::MyHelper.new.do_that

The result will be :

do stuff

do this

do that

Answer 2

I think you may be reasoning about this backwards.

If your engine provides:

module MyEngine
  module MyHelper
    def foo
    end
  end
end

You can extend the method (you could call it decorate but i'm not sure if this is technically the decorator pattern) in your main app:

module MainApp
  module MyHelper
    extend ::MyEngine::MyHelper
    def foo
      super
      do_something_else
    end
  end
end

When using the module-mixin pattern (which is what ActiveSupport::Concern does) you extend modules with modules and include modules in classes.

If you engine and main app "share a partial" - it should just be placed in the engine as Rails will first look for the view when rendering in the app/views directory of the application before looking for it the mounted engines.

The main app can thus always override the functionality provided by the engine while the inverse is not true.

If you want to make a method provided by an engine configurable a better idea is to use a Rails configuration setting (or a seperate module configuration) or just method arguments rather than some crazy circular dependency circus.

Answer 3

So I finally found a way to do this in a "clean" way, as mentioned in the following comment : https://groups.google.com/g/rubyonrails-core/c/PaABJDXnxyo/m/k-QUJEi9a9wJ

The idea is to add an empty placeholder helper in the engine, for example :

module MyEngine
  module ExtendableHelper
  end
end

And then override it in the main app, by adding methods or including concerns, other gems' helpers, etc...

module MyEngine
  module ExtendableHelper
    extend OtherGemFromMainApp::UsefulHelper
    include MainAppConcern
    
    def other_useful_method
      ...
    end
  end
end

Thus the helper used by the engine is the one provided by the app, and the UsefulHelper methods can be called in the engine views.