Render engine within application layout

rails-engines, ruby-on-rails-3, ruby-on-rails-plugins

Solution

I have successfully used layouts of my parent application in my engines. Firstly, based on Section 4.3.2 of the Rails Guides (Engines), in order to access the parent applications ApplicationController's variables (like `session`, as you're using above), you need to replace the engine's `application_controller.rb` from this that you currently have:

module Module1
  class ApplicationController < ActionController::Base
    layout "core"
  end
end

to this:

class Module1::ApplicationController < ::ApplicationController
end

This will inherit the parent application's ApplicationController, along with all it's variables.

Secondly, you'll need to delete the file `app/views/layouts/application.html.erb` from your engine views, as it will not be needed since you're using the parent application's one.

Now when you render a view of Module1 from the parent application, the layout of the parent application will be used, and all the `session[]` variables will be evaluated correctly.

Do not forget to add the words "main_app." before each link in your layouts, otherwise it will try and look for the paths in the engine instead of the parent application. For example, if the layout in the parent application includes a link to `some_path` (that is a view in the parent application), when showing a view in the engine that uses this layout will try and look for `some_path` in the Engine instead of the parent application. You will need to change the link to `main_app.some_path` for it to work.

Hope this helps.

Problem

Background I am creating a application that is made up of a core and several modules. The modules are rails engines, and provide the actual functionality as the core itself only acts as a host. The engines are hosted from `/lib` and mounted at their respective paths. ``` coreApp └──lib ├── module1 ├── module2 └── etc ``` The modules are then mounted like this ``` mount Module1::Engine => "/module1", :as => "module1" mount Module2::Engine => "/module2", :as => "module2" ``` The core is also responsible for handeling the session, although the login itself is done by a module. Problem I have yet to find a great way of sharing the core application layout with the engines. As of now, this is how I make the layout available to the engines: ``` coreApp └── app └── views └── layouts ├── application.html.erb └── core.html.erb ``` The file `core.html.erb` only contains ``` <%= render :template => 'layouts/application' %> ``` Is is then included in each module like this ``` module Module1 class ApplicationController < ActionController::Base layout "core" end end ``` Although it isn't particularly elegant, it works fine, and the content of the module is rendered where the `yield` statement in the application layout. The problems are as follows: 1. Module specific stylesheets are not included in the header I need a way to include the stylesheets of the active module. 2. The header needs access to information about the logged in user The header contains information about the logged in user, like ``` Logged in as <%= @user[:realname] %> ``` This comes from the cores `home_controller` ``` def index @user = User.find_by_id(session[:user]) end ``` But when I try to access the module, I get the following error ``` NoMethodError in Module1/home#index You have a nil object when you didn't expect it! You might have expected an instance of Array. The error occurred while evaluating nil.[] ``` Obviously referring to `@user`. Question How can this be solved in as elegantly and DRY as possible without too much tampering on the engine side? I have Googled this a lot but can't really get my head around how to solve it. It might be total lack of insight in how rails works, so there is a good chance this question doesn't even make sense for someone that knows rails well. Please comment if anything is unclear or ambiguous, and I'll try to elaborate.

Original source